diff options
Diffstat (limited to 'netwerk/base')
308 files changed, 76409 insertions, 0 deletions
diff --git a/netwerk/base/ARefBase.h b/netwerk/base/ARefBase.h new file mode 100644 index 0000000000..cdb3a32e6a --- /dev/null +++ b/netwerk/base/ARefBase.h @@ -0,0 +1,31 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ + +/* 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/. */ + +#ifndef mozilla_net_ARefBase_h +#define mozilla_net_ARefBase_h + +#include "nscore.h" + +namespace mozilla { +namespace net { + +// This is an abstract class that can be pointed to by either +// nsCOMPtr or nsRefPtr. nsHttpConnectionMgr uses it for generic +// objects that need to be reference counted - similiar to nsISupports +// but it may or may not be xpcom. + +class ARefBase { + public: + ARefBase() = default; + virtual ~ARefBase() = default; + + NS_INLINE_DECL_PURE_VIRTUAL_REFCOUNTING +}; + +} // namespace net +} // namespace mozilla + +#endif diff --git a/netwerk/base/ArrayBufferInputStream.cpp b/netwerk/base/ArrayBufferInputStream.cpp new file mode 100644 index 0000000000..d5102051bc --- /dev/null +++ b/netwerk/base/ArrayBufferInputStream.cpp @@ -0,0 +1,125 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 <algorithm> +#include "ArrayBufferInputStream.h" +#include "nsStreamUtils.h" +#include "js/ArrayBuffer.h" // JS::{GetArrayBuffer{ByteLength,Data},IsArrayBufferObject} +#include "js/RootingAPI.h" // JS::{Handle,Rooted} +#include "js/Value.h" // JS::Value +#include "mozilla/UniquePtrExtensions.h" +#include "mozilla/dom/ScriptSettings.h" + +using mozilla::dom::RootingCx; + +NS_IMPL_ISUPPORTS(ArrayBufferInputStream, nsIArrayBufferInputStream, + nsIInputStream); + +ArrayBufferInputStream::ArrayBufferInputStream() + : mBufferLength(0), mPos(0), mClosed(false) {} + +NS_IMETHODIMP +ArrayBufferInputStream::SetData(JS::Handle<JS::Value> aBuffer, + uint32_t aByteOffset, uint32_t aLength) { + NS_ASSERT_OWNINGTHREAD(ArrayBufferInputStream); + + if (!aBuffer.isObject()) { + return NS_ERROR_FAILURE; + } + JS::Rooted<JSObject*> arrayBuffer(RootingCx(), &aBuffer.toObject()); + if (!JS::IsArrayBufferObject(arrayBuffer)) { + return NS_ERROR_FAILURE; + } + + uint32_t buflen = JS::GetArrayBufferByteLength(arrayBuffer); + uint32_t offset = std::min(buflen, aByteOffset); + uint32_t bufferLength = std::min(buflen - offset, aLength); + + mArrayBuffer = mozilla::MakeUniqueFallible<char[]>(bufferLength); + if (!mArrayBuffer) { + return NS_ERROR_OUT_OF_MEMORY; + } + + mBufferLength = bufferLength; + + JS::AutoCheckCannotGC nogc; + bool isShared; + char* src = + (char*)JS::GetArrayBufferData(arrayBuffer, &isShared, nogc) + offset; + memcpy(&mArrayBuffer[0], src, mBufferLength); + return NS_OK; +} + +NS_IMETHODIMP +ArrayBufferInputStream::Close() { + mClosed = true; + return NS_OK; +} + +NS_IMETHODIMP +ArrayBufferInputStream::Available(uint64_t* aCount) { + if (mClosed) { + return NS_BASE_STREAM_CLOSED; + } + if (mArrayBuffer) { + *aCount = mBufferLength ? mBufferLength - mPos : 0; + } else { + *aCount = 0; + } + return NS_OK; +} + +NS_IMETHODIMP +ArrayBufferInputStream::Read(char* aBuf, uint32_t aCount, + uint32_t* aReadCount) { + return ReadSegments(NS_CopySegmentToBuffer, aBuf, aCount, aReadCount); +} + +NS_IMETHODIMP +ArrayBufferInputStream::ReadSegments(nsWriteSegmentFun writer, void* closure, + uint32_t aCount, uint32_t* result) { + NS_ASSERTION(result, "null ptr"); + NS_ASSERTION(mBufferLength >= mPos, "bad stream state"); + + if (mClosed) { + return NS_BASE_STREAM_CLOSED; + } + + MOZ_ASSERT(mArrayBuffer || (mPos == mBufferLength), + "stream inited incorrectly"); + + *result = 0; + while (mPos < mBufferLength) { + uint32_t remaining = mBufferLength - mPos; + MOZ_ASSERT(mArrayBuffer); + + uint32_t count = std::min(aCount, remaining); + if (count == 0) { + break; + } + + uint32_t written; + nsresult rv = writer(this, closure, &mArrayBuffer[0] + mPos, *result, count, + &written); + if (NS_FAILED(rv)) { + // InputStreams do not propagate errors to caller. + return NS_OK; + } + + NS_ASSERTION(written <= count, + "writer should not write more than we asked it to write"); + mPos += written; + *result += written; + aCount -= written; + } + + return NS_OK; +} + +NS_IMETHODIMP +ArrayBufferInputStream::IsNonBlocking(bool* aNonBlocking) { + *aNonBlocking = true; + return NS_OK; +} diff --git a/netwerk/base/ArrayBufferInputStream.h b/netwerk/base/ArrayBufferInputStream.h new file mode 100644 index 0000000000..e38a096764 --- /dev/null +++ b/netwerk/base/ArrayBufferInputStream.h @@ -0,0 +1,40 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef ArrayBufferInputStream_h +#define ArrayBufferInputStream_h + +#include "nsIArrayBufferInputStream.h" +#include "js/Value.h" +#include "mozilla/Maybe.h" +#include "mozilla/UniquePtr.h" +#include "nsISupportsImpl.h" + +#define NS_ARRAYBUFFERINPUTSTREAM_CONTRACTID \ + "@mozilla.org/io/arraybuffer-input-stream;1" +#define NS_ARRAYBUFFERINPUTSTREAM_CID \ + { /* 3014dde6-aa1c-41db-87d0-48764a3710f6 */ \ + 0x3014dde6, 0xaa1c, 0x41db, { \ + 0x87, 0xd0, 0x48, 0x76, 0x4a, 0x37, 0x10, 0xf6 \ + } \ + } + +class ArrayBufferInputStream : public nsIArrayBufferInputStream { + public: + ArrayBufferInputStream(); + + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIARRAYBUFFERINPUTSTREAM + NS_DECL_NSIINPUTSTREAM + + private: + virtual ~ArrayBufferInputStream() = default; + mozilla::UniquePtr<char[]> mArrayBuffer; + uint32_t mBufferLength; + uint32_t mPos; + bool mClosed; +}; + +#endif // ArrayBufferInputStream_h diff --git a/netwerk/base/AutoClose.h b/netwerk/base/AutoClose.h new file mode 100644 index 0000000000..632b29ed7b --- /dev/null +++ b/netwerk/base/AutoClose.h @@ -0,0 +1,62 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=2 et sw=2 tw=80: */ +/* 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/. */ + +#ifndef mozilla_net_AutoClose_h +#define mozilla_net_AutoClose_h + +#include "nsCOMPtr.h" +#include "mozilla/Mutex.h" + +namespace mozilla { +namespace net { + +// A container for XPCOM streams (e.g. nsIAsyncInputStream) and other +// refcounted classes that need to have the Close() method called explicitly +// before they are destroyed. +template <typename T> +class AutoClose { + public: + AutoClose() : mMutex("net::AutoClose.mMutex") {} + ~AutoClose() { CloseAndRelease(); } + + explicit operator bool() { + MutexAutoLock lock(mMutex); + return mPtr; + } + + already_AddRefed<T> forget() { + MutexAutoLock lock(mMutex); + return mPtr.forget(); + } + + void takeOver(nsCOMPtr<T>& rhs) { TakeOverInternal(rhs.forget()); } + + void CloseAndRelease() { TakeOverInternal(nullptr); } + + private: + void TakeOverInternal(already_AddRefed<T>&& aOther) { + nsCOMPtr<T> ptr(std::move(aOther)); + { + MutexAutoLock lock(mMutex); + ptr.swap(mPtr); + } + + if (ptr) { + ptr->Close(); + } + } + + void operator=(const AutoClose<T>&) = delete; + AutoClose(const AutoClose<T>&) = delete; + + nsCOMPtr<T> mPtr; + Mutex mMutex; +}; + +} // namespace net +} // namespace mozilla + +#endif // mozilla_net_AutoClose_h diff --git a/netwerk/base/BackgroundFileSaver.cpp b/netwerk/base/BackgroundFileSaver.cpp new file mode 100644 index 0000000000..7c77038f08 --- /dev/null +++ b/netwerk/base/BackgroundFileSaver.cpp @@ -0,0 +1,1120 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=2 et sw=2 tw=80: */ +/* 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 "BackgroundFileSaver.h" + +#include "ScopedNSSTypes.h" +#include "mozilla/ArrayAlgorithm.h" +#include "mozilla/Casting.h" +#include "mozilla/Logging.h" +#include "mozilla/Telemetry.h" +#include "nsCOMArray.h" +#include "nsComponentManagerUtils.h" +#include "nsDependentSubstring.h" +#include "nsIAsyncInputStream.h" +#include "nsIFile.h" +#include "nsIMutableArray.h" +#include "nsIPipe.h" +#include "nsNetUtil.h" +#include "nsThreadUtils.h" +#include "pk11pub.h" +#include "secoidt.h" + +#ifdef XP_WIN +# include <windows.h> +# include <softpub.h> +# include <wintrust.h> +#endif // XP_WIN + +namespace mozilla { +namespace net { + +// MOZ_LOG=BackgroundFileSaver:5 +static LazyLogModule prlog("BackgroundFileSaver"); +#define LOG(args) MOZ_LOG(prlog, mozilla::LogLevel::Debug, args) +#define LOG_ENABLED() MOZ_LOG_TEST(prlog, mozilla::LogLevel::Debug) + +//////////////////////////////////////////////////////////////////////////////// +//// Globals + +/** + * Buffer size for writing to the output file or reading from the input file. + */ +#define BUFFERED_IO_SIZE (1024 * 32) + +/** + * When this upper limit is reached, the original request is suspended. + */ +#define REQUEST_SUSPEND_AT (1024 * 1024 * 4) + +/** + * When this lower limit is reached, the original request is resumed. + */ +#define REQUEST_RESUME_AT (1024 * 1024 * 2) + +//////////////////////////////////////////////////////////////////////////////// +//// NotifyTargetChangeRunnable + +/** + * Runnable object used to notify the control thread that file contents will now + * be saved to the specified file. + */ +class NotifyTargetChangeRunnable final : public Runnable { + public: + NotifyTargetChangeRunnable(BackgroundFileSaver* aSaver, nsIFile* aTarget) + : Runnable("net::NotifyTargetChangeRunnable"), + mSaver(aSaver), + mTarget(aTarget) {} + + NS_IMETHOD Run() override { return mSaver->NotifyTargetChange(mTarget); } + + private: + RefPtr<BackgroundFileSaver> mSaver; + nsCOMPtr<nsIFile> mTarget; +}; + +//////////////////////////////////////////////////////////////////////////////// +//// BackgroundFileSaver + +uint32_t BackgroundFileSaver::sThreadCount = 0; +uint32_t BackgroundFileSaver::sTelemetryMaxThreadCount = 0; + +BackgroundFileSaver::BackgroundFileSaver() + : mControlEventTarget(nullptr), + mBackgroundET(nullptr), + mPipeOutputStream(nullptr), + mPipeInputStream(nullptr), + mObserver(nullptr), + mLock("BackgroundFileSaver.mLock"), + mWorkerThreadAttentionRequested(false), + mFinishRequested(false), + mComplete(false), + mStatus(NS_OK), + mAppend(false), + mInitialTarget(nullptr), + mInitialTargetKeepPartial(false), + mRenamedTarget(nullptr), + mRenamedTargetKeepPartial(false), + mAsyncCopyContext(nullptr), + mSha256Enabled(false), + mSignatureInfoEnabled(false), + mActualTarget(nullptr), + mActualTargetKeepPartial(false) { + LOG(("Created BackgroundFileSaver [this = %p]", this)); +} + +BackgroundFileSaver::~BackgroundFileSaver() { + LOG(("Destroying BackgroundFileSaver [this = %p]", this)); +} + +// Called on the control thread. +nsresult BackgroundFileSaver::Init() { + MOZ_ASSERT(NS_IsMainThread(), "This should be called on the main thread"); + + nsresult rv; + + rv = NS_NewPipe2(getter_AddRefs(mPipeInputStream), + getter_AddRefs(mPipeOutputStream), true, true, 0, + HasInfiniteBuffer() ? UINT32_MAX : 0); + NS_ENSURE_SUCCESS(rv, rv); + + mControlEventTarget = GetCurrentEventTarget(); + NS_ENSURE_TRUE(mControlEventTarget, NS_ERROR_NOT_INITIALIZED); + + rv = NS_CreateBackgroundTaskQueue("BgFileSaver", + getter_AddRefs(mBackgroundET)); + NS_ENSURE_SUCCESS(rv, rv); + + sThreadCount++; + if (sThreadCount > sTelemetryMaxThreadCount) { + sTelemetryMaxThreadCount = sThreadCount; + } + + return NS_OK; +} + +// Called on the control thread. +NS_IMETHODIMP +BackgroundFileSaver::GetObserver(nsIBackgroundFileSaverObserver** aObserver) { + NS_ENSURE_ARG_POINTER(aObserver); + *aObserver = mObserver; + NS_IF_ADDREF(*aObserver); + return NS_OK; +} + +// Called on the control thread. +NS_IMETHODIMP +BackgroundFileSaver::SetObserver(nsIBackgroundFileSaverObserver* aObserver) { + mObserver = aObserver; + return NS_OK; +} + +// Called on the control thread. +NS_IMETHODIMP +BackgroundFileSaver::EnableAppend() { + MOZ_ASSERT(NS_IsMainThread(), "This should be called on the main thread"); + + MutexAutoLock lock(mLock); + mAppend = true; + + return NS_OK; +} + +// Called on the control thread. +NS_IMETHODIMP +BackgroundFileSaver::SetTarget(nsIFile* aTarget, bool aKeepPartial) { + NS_ENSURE_ARG(aTarget); + { + MutexAutoLock lock(mLock); + if (!mInitialTarget) { + aTarget->Clone(getter_AddRefs(mInitialTarget)); + mInitialTargetKeepPartial = aKeepPartial; + } else { + aTarget->Clone(getter_AddRefs(mRenamedTarget)); + mRenamedTargetKeepPartial = aKeepPartial; + } + } + + // After the worker thread wakes up because attention is requested, it will + // rename or create the target file as requested, and start copying data. + return GetWorkerThreadAttention(true); +} + +// Called on the control thread. +NS_IMETHODIMP +BackgroundFileSaver::Finish(nsresult aStatus) { + nsresult rv; + + // This will cause the NS_AsyncCopy operation, if it's in progress, to consume + // all the data that is still in the pipe, and then finish. + rv = mPipeOutputStream->Close(); + NS_ENSURE_SUCCESS(rv, rv); + + // Ensure that, when we get attention from the worker thread, if no pending + // rename operation is waiting, the operation will complete. + { + MutexAutoLock lock(mLock); + mFinishRequested = true; + if (NS_SUCCEEDED(mStatus)) { + mStatus = aStatus; + } + } + + // After the worker thread wakes up because attention is requested, it will + // process the completion conditions, detect that completion is requested, and + // notify the main thread of the completion. If this function was called with + // a success code, we wait for the copy to finish before processing the + // completion conditions, otherwise we interrupt the copy immediately. + return GetWorkerThreadAttention(NS_FAILED(aStatus)); +} + +NS_IMETHODIMP +BackgroundFileSaver::EnableSha256() { + MOZ_ASSERT(NS_IsMainThread(), + "Can't enable sha256 or initialize NSS off the main thread"); + // Ensure Personal Security Manager is initialized. This is required for + // PK11_* operations to work. + nsresult rv; + nsCOMPtr<nsISupports> nssDummy = do_GetService("@mozilla.org/psm;1", &rv); + NS_ENSURE_SUCCESS(rv, rv); + mSha256Enabled = true; + return NS_OK; +} + +NS_IMETHODIMP +BackgroundFileSaver::GetSha256Hash(nsACString& aHash) { + MOZ_ASSERT(NS_IsMainThread(), "Can't inspect sha256 off the main thread"); + // We acquire a lock because mSha256 is written on the worker thread. + MutexAutoLock lock(mLock); + if (mSha256.IsEmpty()) { + return NS_ERROR_NOT_AVAILABLE; + } + aHash = mSha256; + return NS_OK; +} + +NS_IMETHODIMP +BackgroundFileSaver::EnableSignatureInfo() { + MOZ_ASSERT(NS_IsMainThread(), + "Can't enable signature extraction off the main thread"); + // Ensure Personal Security Manager is initialized. + nsresult rv; + nsCOMPtr<nsISupports> nssDummy = do_GetService("@mozilla.org/psm;1", &rv); + NS_ENSURE_SUCCESS(rv, rv); + mSignatureInfoEnabled = true; + return NS_OK; +} + +NS_IMETHODIMP +BackgroundFileSaver::GetSignatureInfo( + nsTArray<nsTArray<nsTArray<uint8_t>>>& aSignatureInfo) { + MOZ_ASSERT(NS_IsMainThread(), "Can't inspect signature off the main thread"); + // We acquire a lock because mSignatureInfo is written on the worker thread. + MutexAutoLock lock(mLock); + if (!mComplete || !mSignatureInfoEnabled) { + return NS_ERROR_NOT_AVAILABLE; + } + for (const auto& signatureChain : mSignatureInfo) { + aSignatureInfo.AppendElement(TransformIntoNewArray( + signatureChain, [](const auto& element) { return element.Clone(); })); + } + return NS_OK; +} + +// Called on the control thread. +nsresult BackgroundFileSaver::GetWorkerThreadAttention( + bool aShouldInterruptCopy) { + nsresult rv; + + MutexAutoLock lock(mLock); + + // We only require attention one time. If this function is called two times + // before the worker thread wakes up, and the first has aShouldInterruptCopy + // false and the second true, we won't forcibly interrupt the copy from the + // control thread. However, that never happens, because calling Finish with a + // success code is the only case that may result in aShouldInterruptCopy being + // false. In that case, we won't call this function again, because consumers + // should not invoke other methods on the control thread after calling Finish. + // And in any case, Finish already closes one end of the pipe, causing the + // copy to finish properly on its own. + if (mWorkerThreadAttentionRequested) { + return NS_OK; + } + + if (!mAsyncCopyContext) { + // Background event queues are not shutdown and could be called after + // the queue is reset to null. To match the behavior of nsIThread + // return NS_ERROR_UNEXPECTED + if (!mBackgroundET) { + return NS_ERROR_UNEXPECTED; + } + + // Copy is not in progress, post an event to handle the change manually. + rv = mBackgroundET->Dispatch( + NewRunnableMethod("net::BackgroundFileSaver::ProcessAttention", this, + &BackgroundFileSaver::ProcessAttention), + NS_DISPATCH_EVENT_MAY_BLOCK); + NS_ENSURE_SUCCESS(rv, rv); + + } else if (aShouldInterruptCopy) { + // Interrupt the copy. The copy will be resumed, if needed, by the + // ProcessAttention function, invoked by the AsyncCopyCallback function. + NS_CancelAsyncCopy(mAsyncCopyContext, NS_ERROR_ABORT); + } + + // Indicate that attention has been requested successfully, there is no need + // to post another event until the worker thread processes the current one. + mWorkerThreadAttentionRequested = true; + + return NS_OK; +} + +// Called on the worker thread. +// static +void BackgroundFileSaver::AsyncCopyCallback(void* aClosure, nsresult aStatus) { + // We called NS_ADDREF_THIS when NS_AsyncCopy started, to keep the object + // alive even if other references disappeared. At the end of this method, + // we've finished using the object and can safely release our reference. + RefPtr<BackgroundFileSaver> self = + dont_AddRef((BackgroundFileSaver*)aClosure); + { + MutexAutoLock lock(self->mLock); + + // Now that the copy was interrupted or terminated, any notification from + // the control thread requires an event to be posted to the worker thread. + self->mAsyncCopyContext = nullptr; + + // When detecting failures, ignore the status code we use to interrupt. + if (NS_FAILED(aStatus) && aStatus != NS_ERROR_ABORT && + NS_SUCCEEDED(self->mStatus)) { + self->mStatus = aStatus; + } + } + + (void)self->ProcessAttention(); +} + +// Called on the worker thread. +nsresult BackgroundFileSaver::ProcessAttention() { + nsresult rv; + + // This function is called whenever the attention of the worker thread has + // been requested. This may happen in these cases: + // * We are about to start the copy for the first time. In this case, we are + // called from an event posted on the worker thread from the control thread + // by GetWorkerThreadAttention, and mAsyncCopyContext is null. + // * We have interrupted the copy for some reason. In this case, we are + // called by AsyncCopyCallback, and mAsyncCopyContext is null. + // * We are currently executing ProcessStateChange, and attention is requested + // by the control thread, for example because SetTarget or Finish have been + // called. In this case, we are called from from an event posted through + // GetWorkerThreadAttention. While mAsyncCopyContext was always null when + // the event was posted, at this point mAsyncCopyContext may not be null + // anymore, because ProcessStateChange may have started the copy before the + // event that called this function was processed on the worker thread. + // If mAsyncCopyContext is not null, we interrupt the copy and re-enter + // through AsyncCopyCallback. This allows us to check if, for instance, we + // should rename the target file. We will then restart the copy if needed. + if (mAsyncCopyContext) { + NS_CancelAsyncCopy(mAsyncCopyContext, NS_ERROR_ABORT); + return NS_OK; + } + // Use the current shared state to determine the next operation to execute. + rv = ProcessStateChange(); + if (NS_FAILED(rv)) { + // If something failed while processing, terminate the operation now. + { + MutexAutoLock lock(mLock); + + if (NS_SUCCEEDED(mStatus)) { + mStatus = rv; + } + } + // Ensure we notify completion now that the operation failed. + CheckCompletion(); + } + + return NS_OK; +} + +// Called on the worker thread. +nsresult BackgroundFileSaver::ProcessStateChange() { + nsresult rv; + + // We might have been notified because the operation is complete, verify. + if (CheckCompletion()) { + return NS_OK; + } + + // Get a copy of the current shared state for the worker thread. + nsCOMPtr<nsIFile> initialTarget; + bool initialTargetKeepPartial; + nsCOMPtr<nsIFile> renamedTarget; + bool renamedTargetKeepPartial; + bool sha256Enabled; + bool append; + { + MutexAutoLock lock(mLock); + + initialTarget = mInitialTarget; + initialTargetKeepPartial = mInitialTargetKeepPartial; + renamedTarget = mRenamedTarget; + renamedTargetKeepPartial = mRenamedTargetKeepPartial; + sha256Enabled = mSha256Enabled; + append = mAppend; + + // From now on, another attention event needs to be posted if state changes. + mWorkerThreadAttentionRequested = false; + } + + // The initial target can only be null if it has never been assigned. In this + // case, there is nothing to do since we never created any output file. + if (!initialTarget) { + return NS_OK; + } + + // Determine if we are processing the attention request for the first time. + bool isContinuation = !!mActualTarget; + if (!isContinuation) { + // Assign the target file for the first time. + mActualTarget = initialTarget; + mActualTargetKeepPartial = initialTargetKeepPartial; + } + + // Verify whether we have actually been instructed to use a different file. + // This may happen the first time this function is executed, if SetTarget was + // called two times before the worker thread processed the attention request. + bool equalToCurrent = false; + if (renamedTarget) { + rv = mActualTarget->Equals(renamedTarget, &equalToCurrent); + NS_ENSURE_SUCCESS(rv, rv); + if (!equalToCurrent) { + // If we were asked to rename the file but the initial file did not exist, + // we simply create the file in the renamed location. We avoid this check + // if we have already started writing the output file ourselves. + bool exists = true; + if (!isContinuation) { + rv = mActualTarget->Exists(&exists); + NS_ENSURE_SUCCESS(rv, rv); + } + if (exists) { + // We are moving the previous target file to a different location. + nsCOMPtr<nsIFile> renamedTargetParentDir; + rv = renamedTarget->GetParent(getter_AddRefs(renamedTargetParentDir)); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoString renamedTargetName; + rv = renamedTarget->GetLeafName(renamedTargetName); + NS_ENSURE_SUCCESS(rv, rv); + + // We must delete any existing target file before moving the current + // one. + rv = renamedTarget->Exists(&exists); + NS_ENSURE_SUCCESS(rv, rv); + if (exists) { + rv = renamedTarget->Remove(false); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Move the file. If this fails, we still reference the original file + // in mActualTarget, so that it is deleted if requested. If this + // succeeds, the nsIFile instance referenced by mActualTarget mutates + // and starts pointing to the new file, but we'll discard the reference. + rv = mActualTarget->MoveTo(renamedTargetParentDir, renamedTargetName); + NS_ENSURE_SUCCESS(rv, rv); + } + + // We should not only update the mActualTarget with renameTarget when + // they point to the different files. + // In this way, if mActualTarget and renamedTarget point to the same file + // with different addresses, "CheckCompletion()" will return false + // forever. + } + + // Update mActualTarget with renameTarget, + // even if they point to the same file. + mActualTarget = renamedTarget; + mActualTargetKeepPartial = renamedTargetKeepPartial; + } + + // Notify if the target file name actually changed. + if (!equalToCurrent) { + // We must clone the nsIFile instance because mActualTarget is not + // immutable, it may change if the target is renamed later. + nsCOMPtr<nsIFile> actualTargetToNotify; + rv = mActualTarget->Clone(getter_AddRefs(actualTargetToNotify)); + NS_ENSURE_SUCCESS(rv, rv); + + RefPtr<NotifyTargetChangeRunnable> event = + new NotifyTargetChangeRunnable(this, actualTargetToNotify); + NS_ENSURE_TRUE(event, NS_ERROR_FAILURE); + + rv = mControlEventTarget->Dispatch(event, NS_DISPATCH_NORMAL); + NS_ENSURE_SUCCESS(rv, rv); + } + + if (isContinuation) { + // The pending rename operation might be the last task before finishing. We + // may return here only if we have already created the target file. + if (CheckCompletion()) { + return NS_OK; + } + + // Even if the operation did not complete, the pipe input stream may be + // empty and may have been closed already. We detect this case using the + // Available property, because it never returns an error if there is more + // data to be consumed. If the pipe input stream is closed, we just exit + // and wait for more calls like SetTarget or Finish to be invoked on the + // control thread. However, we still truncate the file or create the + // initial digest context if we are expected to do that. + uint64_t available; + rv = mPipeInputStream->Available(&available); + if (NS_FAILED(rv)) { + return NS_OK; + } + } + + // Create the digest if requested and NSS hasn't been shut down. + if (sha256Enabled && mDigest.isNothing()) { + mDigest.emplace(Digest()); + mDigest->Begin(SEC_OID_SHA256); + } + + // When we are requested to append to an existing file, we should read the + // existing data and ensure we include it as part of the final hash. + if (mDigest.isSome() && append && !isContinuation) { + nsCOMPtr<nsIInputStream> inputStream; + rv = NS_NewLocalFileInputStream(getter_AddRefs(inputStream), mActualTarget, + PR_RDONLY | nsIFile::OS_READAHEAD); + if (rv != NS_ERROR_FILE_NOT_FOUND) { + NS_ENSURE_SUCCESS(rv, rv); + + char buffer[BUFFERED_IO_SIZE]; + while (true) { + uint32_t count; + rv = inputStream->Read(buffer, BUFFERED_IO_SIZE, &count); + NS_ENSURE_SUCCESS(rv, rv); + + if (count == 0) { + // We reached the end of the file. + break; + } + + nsresult rv = + mDigest->Update(BitwiseCast<unsigned char*, char*>(buffer), count); + NS_ENSURE_SUCCESS(rv, rv); + } + + rv = inputStream->Close(); + NS_ENSURE_SUCCESS(rv, rv); + } + } + + // We will append to the initial target file only if it was requested by the + // caller, but we'll always append on subsequent accesses to the target file. + int32_t creationIoFlags; + if (isContinuation) { + creationIoFlags = PR_APPEND; + } else { + creationIoFlags = (append ? PR_APPEND : PR_TRUNCATE) | PR_CREATE_FILE; + } + + // Create the target file, or append to it if we already started writing it. + // The 0600 permissions are used while the file is being downloaded, and for + // interrupted downloads. Those may be located in the system temporary + // directory, as well as the target directory, and generally have a ".part" + // extension. Those part files should never be group or world-writable even + // if the umask allows it. + nsCOMPtr<nsIOutputStream> outputStream; + rv = NS_NewLocalFileOutputStream(getter_AddRefs(outputStream), mActualTarget, + PR_WRONLY | creationIoFlags, 0600); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIOutputStream> bufferedStream; + rv = NS_NewBufferedOutputStream(getter_AddRefs(bufferedStream), + outputStream.forget(), BUFFERED_IO_SIZE); + NS_ENSURE_SUCCESS(rv, rv); + outputStream = bufferedStream; + + // Wrap the output stream so that it feeds the digest if needed. + if (mDigest.isSome()) { + // Constructing the DigestOutputStream cannot fail. Passing mDigest + // to DigestOutputStream is safe, because BackgroundFileSaver always + // outlives the outputStream. BackgroundFileSaver is reference-counted + // before the call to AsyncCopy, and mDigest is never destroyed + // before AsyncCopyCallback. + outputStream = new DigestOutputStream(outputStream, mDigest.ref()); + } + + // Start copying our input to the target file. No errors can be raised past + // this point if the copy starts, since they should be handled by the thread. + { + MutexAutoLock lock(mLock); + + rv = NS_AsyncCopy(mPipeInputStream, outputStream, mBackgroundET, + NS_ASYNCCOPY_VIA_READSEGMENTS, 4096, AsyncCopyCallback, + this, false, true, getter_AddRefs(mAsyncCopyContext), + GetProgressCallback()); + if (NS_FAILED(rv)) { + NS_WARNING("NS_AsyncCopy failed."); + mAsyncCopyContext = nullptr; + return rv; + } + } + + // If the operation succeeded, we must ensure that we keep this object alive + // for the entire duration of the copy, since only the raw pointer will be + // provided as the argument of the AsyncCopyCallback function. We can add the + // reference now, after NS_AsyncCopy returned, because it always starts + // processing asynchronously, and there is no risk that the callback is + // invoked before we reach this point. If the operation failed instead, then + // AsyncCopyCallback will never be called. + NS_ADDREF_THIS(); + + return NS_OK; +} + +// Called on the worker thread. +bool BackgroundFileSaver::CheckCompletion() { + nsresult rv; + + MOZ_ASSERT(!mAsyncCopyContext, + "Should not be copying when checking completion conditions."); + + bool failed = true; + { + MutexAutoLock lock(mLock); + + if (mComplete) { + return true; + } + + // If an error occurred, we don't need to do the checks in this code block, + // and the operation can be completed immediately with a failure code. + if (NS_SUCCEEDED(mStatus)) { + failed = false; + + // We did not incur in an error, so we must determine if we can stop now. + // If the Finish method has not been called, we can just continue now. + if (!mFinishRequested) { + return false; + } + + // We can only stop when all the operations requested by the control + // thread have been processed. First, we check whether we have processed + // the first SetTarget call, if any. Then, we check whether we have + // processed any rename requested by subsequent SetTarget calls. + if ((mInitialTarget && !mActualTarget) || + (mRenamedTarget && mRenamedTarget != mActualTarget)) { + return false; + } + + // If we still have data to write to the output file, allow the copy + // operation to resume. The Available getter may return an error if one + // of the pipe's streams has been already closed. + uint64_t available; + rv = mPipeInputStream->Available(&available); + if (NS_SUCCEEDED(rv) && available != 0) { + return false; + } + } + + mComplete = true; + } + + // Ensure we notify completion now that the operation finished. + // Do a best-effort attempt to remove the file if required. + if (failed && mActualTarget && !mActualTargetKeepPartial) { + (void)mActualTarget->Remove(false); + } + + // Finish computing the hash + if (!failed && mDigest.isSome()) { + nsTArray<uint8_t> outArray; + rv = mDigest->End(outArray); + if (NS_SUCCEEDED(rv)) { + MutexAutoLock lock(mLock); + mSha256 = nsDependentCSubstring( + BitwiseCast<char*, uint8_t*>(outArray.Elements()), outArray.Length()); + } + } + + // Compute the signature of the binary. ExtractSignatureInfo doesn't do + // anything on non-Windows platforms except return an empty nsIArray. + if (!failed && mActualTarget) { + nsString filePath; + mActualTarget->GetTarget(filePath); + nsresult rv = ExtractSignatureInfo(filePath); + if (NS_FAILED(rv)) { + LOG(("Unable to extract signature information [this = %p].", this)); + } else { + LOG(("Signature extraction success! [this = %p]", this)); + } + } + + // Post an event to notify that the operation completed. + if (NS_FAILED(mControlEventTarget->Dispatch( + NewRunnableMethod("BackgroundFileSaver::NotifySaveComplete", this, + &BackgroundFileSaver::NotifySaveComplete), + NS_DISPATCH_NORMAL))) { + NS_WARNING("Unable to post completion event to the control thread."); + } + + return true; +} + +// Called on the control thread. +nsresult BackgroundFileSaver::NotifyTargetChange(nsIFile* aTarget) { + if (mObserver) { + (void)mObserver->OnTargetChange(this, aTarget); + } + + return NS_OK; +} + +// Called on the control thread. +nsresult BackgroundFileSaver::NotifySaveComplete() { + MOZ_ASSERT(NS_IsMainThread(), "This should be called on the main thread"); + + nsresult status; + { + MutexAutoLock lock(mLock); + status = mStatus; + } + + if (mObserver) { + (void)mObserver->OnSaveComplete(this, status); + // If mObserver keeps alive an enclosure that captures `this`, we'll have a + // cycle that won't be caught by the cycle-collector, so we need to break it + // when we're done here (see bug 1444265). + mObserver = nullptr; + } + + // At this point, the worker thread will not process any more events, and we + // can shut it down. Shutting down a thread may re-enter the event loop on + // this thread. This is not a problem in this case, since this function is + // called by a top-level event itself, and we have already invoked the + // completion observer callback. Re-entering the loop can only delay the + // final release and destruction of this saver object, since we are keeping a + // reference to it through the event object. + mBackgroundET = nullptr; + + sThreadCount--; + + // When there are no more active downloads, we consider the download session + // finished. We record the maximum number of concurrent downloads reached + // during the session in a telemetry histogram, and we reset the maximum + // thread counter for the next download session + if (sThreadCount == 0) { + Telemetry::Accumulate(Telemetry::BACKGROUNDFILESAVER_THREAD_COUNT, + sTelemetryMaxThreadCount); + sTelemetryMaxThreadCount = 0; + } + + return NS_OK; +} + +nsresult BackgroundFileSaver::ExtractSignatureInfo(const nsAString& filePath) { + MOZ_ASSERT(!NS_IsMainThread(), "Cannot extract signature on main thread"); + { + MutexAutoLock lock(mLock); + if (!mSignatureInfoEnabled) { + return NS_OK; + } + } +#ifdef XP_WIN + // Setup the file to check. + WINTRUST_FILE_INFO fileToCheck = {0}; + fileToCheck.cbStruct = sizeof(WINTRUST_FILE_INFO); + fileToCheck.pcwszFilePath = filePath.Data(); + fileToCheck.hFile = nullptr; + fileToCheck.pgKnownSubject = nullptr; + + // We want to check it is signed and trusted. + WINTRUST_DATA trustData = {0}; + trustData.cbStruct = sizeof(trustData); + trustData.pPolicyCallbackData = nullptr; + trustData.pSIPClientData = nullptr; + trustData.dwUIChoice = WTD_UI_NONE; + trustData.fdwRevocationChecks = WTD_REVOKE_NONE; + trustData.dwUnionChoice = WTD_CHOICE_FILE; + trustData.dwStateAction = WTD_STATEACTION_VERIFY; + trustData.hWVTStateData = nullptr; + trustData.pwszURLReference = nullptr; + // Disallow revocation checks over the network + trustData.dwProvFlags = WTD_CACHE_ONLY_URL_RETRIEVAL; + // no UI + trustData.dwUIContext = 0; + trustData.pFile = &fileToCheck; + + // The WINTRUST_ACTION_GENERIC_VERIFY_V2 policy verifies that the certificate + // chains up to a trusted root CA and has appropriate permissions to sign + // code. + GUID policyGUID = WINTRUST_ACTION_GENERIC_VERIFY_V2; + // Check if the file is signed by something that is trusted. If the file is + // not signed, this is a no-op. + LONG ret = WinVerifyTrust(nullptr, &policyGUID, &trustData); + CRYPT_PROVIDER_DATA* cryptoProviderData = nullptr; + // According to the Windows documentation, we should check against 0 instead + // of ERROR_SUCCESS, which is an HRESULT. + if (ret == 0) { + cryptoProviderData = WTHelperProvDataFromStateData(trustData.hWVTStateData); + } + if (cryptoProviderData) { + // Lock because signature information is read on the main thread. + MutexAutoLock lock(mLock); + LOG(("Downloaded trusted and signed file [this = %p].", this)); + // A binary may have multiple signers. Each signer may have multiple certs + // in the chain. + for (DWORD i = 0; i < cryptoProviderData->csSigners; ++i) { + const CERT_CHAIN_CONTEXT* certChainContext = + cryptoProviderData->pasSigners[i].pChainContext; + if (!certChainContext) { + break; + } + for (DWORD j = 0; j < certChainContext->cChain; ++j) { + const CERT_SIMPLE_CHAIN* certSimpleChain = + certChainContext->rgpChain[j]; + if (!certSimpleChain) { + break; + } + + nsTArray<nsTArray<uint8_t>> certList; + bool extractionSuccess = true; + for (DWORD k = 0; k < certSimpleChain->cElement; ++k) { + CERT_CHAIN_ELEMENT* certChainElement = certSimpleChain->rgpElement[k]; + if (certChainElement->pCertContext->dwCertEncodingType != + X509_ASN_ENCODING) { + continue; + } + nsTArray<uint8_t> cert; + cert.AppendElements(certChainElement->pCertContext->pbCertEncoded, + certChainElement->pCertContext->cbCertEncoded); + certList.AppendElement(std::move(cert)); + } + if (extractionSuccess) { + mSignatureInfo.AppendElement(std::move(certList)); + } + } + } + // Free the provider data if cryptoProviderData is not null. + trustData.dwStateAction = WTD_STATEACTION_CLOSE; + WinVerifyTrust(nullptr, &policyGUID, &trustData); + } else { + LOG(("Downloaded unsigned or untrusted file [this = %p].", this)); + } +#endif + return NS_OK; +} + +//////////////////////////////////////////////////////////////////////////////// +//// BackgroundFileSaverOutputStream + +NS_IMPL_ISUPPORTS(BackgroundFileSaverOutputStream, nsIBackgroundFileSaver, + nsIOutputStream, nsIAsyncOutputStream, + nsIOutputStreamCallback) + +BackgroundFileSaverOutputStream::BackgroundFileSaverOutputStream() + : BackgroundFileSaver(), mAsyncWaitCallback(nullptr) {} + +bool BackgroundFileSaverOutputStream::HasInfiniteBuffer() { return false; } + +nsAsyncCopyProgressFun BackgroundFileSaverOutputStream::GetProgressCallback() { + return nullptr; +} + +NS_IMETHODIMP +BackgroundFileSaverOutputStream::Close() { return mPipeOutputStream->Close(); } + +NS_IMETHODIMP +BackgroundFileSaverOutputStream::Flush() { return mPipeOutputStream->Flush(); } + +NS_IMETHODIMP +BackgroundFileSaverOutputStream::Write(const char* aBuf, uint32_t aCount, + uint32_t* _retval) { + return mPipeOutputStream->Write(aBuf, aCount, _retval); +} + +NS_IMETHODIMP +BackgroundFileSaverOutputStream::WriteFrom(nsIInputStream* aFromStream, + uint32_t aCount, uint32_t* _retval) { + return mPipeOutputStream->WriteFrom(aFromStream, aCount, _retval); +} + +NS_IMETHODIMP +BackgroundFileSaverOutputStream::WriteSegments(nsReadSegmentFun aReader, + void* aClosure, uint32_t aCount, + uint32_t* _retval) { + return mPipeOutputStream->WriteSegments(aReader, aClosure, aCount, _retval); +} + +NS_IMETHODIMP +BackgroundFileSaverOutputStream::IsNonBlocking(bool* _retval) { + return mPipeOutputStream->IsNonBlocking(_retval); +} + +NS_IMETHODIMP +BackgroundFileSaverOutputStream::CloseWithStatus(nsresult reason) { + return mPipeOutputStream->CloseWithStatus(reason); +} + +NS_IMETHODIMP +BackgroundFileSaverOutputStream::AsyncWait(nsIOutputStreamCallback* aCallback, + uint32_t aFlags, + uint32_t aRequestedCount, + nsIEventTarget* aEventTarget) { + NS_ENSURE_STATE(!mAsyncWaitCallback); + + mAsyncWaitCallback = aCallback; + + return mPipeOutputStream->AsyncWait(this, aFlags, aRequestedCount, + aEventTarget); +} + +NS_IMETHODIMP +BackgroundFileSaverOutputStream::OnOutputStreamReady( + nsIAsyncOutputStream* aStream) { + NS_ENSURE_STATE(mAsyncWaitCallback); + + nsCOMPtr<nsIOutputStreamCallback> asyncWaitCallback = nullptr; + asyncWaitCallback.swap(mAsyncWaitCallback); + + return asyncWaitCallback->OnOutputStreamReady(this); +} + +//////////////////////////////////////////////////////////////////////////////// +//// BackgroundFileSaverStreamListener + +NS_IMPL_ISUPPORTS(BackgroundFileSaverStreamListener, nsIBackgroundFileSaver, + nsIRequestObserver, nsIStreamListener) + +BackgroundFileSaverStreamListener::BackgroundFileSaverStreamListener() + : BackgroundFileSaver(), + mSuspensionLock("BackgroundFileSaverStreamListener.mSuspensionLock"), + mReceivedTooMuchData(false), + mRequest(nullptr), + mRequestSuspended(false) {} + +bool BackgroundFileSaverStreamListener::HasInfiniteBuffer() { return true; } + +nsAsyncCopyProgressFun +BackgroundFileSaverStreamListener::GetProgressCallback() { + return AsyncCopyProgressCallback; +} + +NS_IMETHODIMP +BackgroundFileSaverStreamListener::OnStartRequest(nsIRequest* aRequest) { + NS_ENSURE_ARG(aRequest); + + return NS_OK; +} + +NS_IMETHODIMP +BackgroundFileSaverStreamListener::OnStopRequest(nsIRequest* aRequest, + nsresult aStatusCode) { + // If an error occurred, cancel the operation immediately. On success, wait + // until the caller has determined whether the file should be renamed. + if (NS_FAILED(aStatusCode)) { + Finish(aStatusCode); + } + + return NS_OK; +} + +NS_IMETHODIMP +BackgroundFileSaverStreamListener::OnDataAvailable(nsIRequest* aRequest, + nsIInputStream* aInputStream, + uint64_t aOffset, + uint32_t aCount) { + nsresult rv; + + NS_ENSURE_ARG(aRequest); + + // Read the requested data. Since the pipe has an infinite buffer, we don't + // expect any write error to occur here. + uint32_t writeCount; + rv = mPipeOutputStream->WriteFrom(aInputStream, aCount, &writeCount); + NS_ENSURE_SUCCESS(rv, rv); + + // If reading from the input stream fails for any reason, the pipe will return + // a success code, but without reading all the data. Since we should be able + // to read the requested data when OnDataAvailable is called, raise an error. + if (writeCount < aCount) { + NS_WARNING("Reading from the input stream should not have failed."); + return NS_ERROR_UNEXPECTED; + } + + bool stateChanged = false; + { + MutexAutoLock lock(mSuspensionLock); + + if (!mReceivedTooMuchData) { + uint64_t available; + nsresult rv = mPipeInputStream->Available(&available); + if (NS_SUCCEEDED(rv) && available > REQUEST_SUSPEND_AT) { + mReceivedTooMuchData = true; + mRequest = aRequest; + stateChanged = true; + } + } + } + + if (stateChanged) { + NotifySuspendOrResume(); + } + + return NS_OK; +} + +// Called on the worker thread. +// static +void BackgroundFileSaverStreamListener::AsyncCopyProgressCallback( + void* aClosure, uint32_t aCount) { + BackgroundFileSaverStreamListener* self = + (BackgroundFileSaverStreamListener*)aClosure; + + // Wait if the control thread is in the process of suspending or resuming. + MutexAutoLock lock(self->mSuspensionLock); + + // This function is called when some bytes are consumed by NS_AsyncCopy. Each + // time this happens, verify if a suspended request should be resumed, because + // we have now consumed enough data. + if (self->mReceivedTooMuchData) { + uint64_t available; + nsresult rv = self->mPipeInputStream->Available(&available); + if (NS_FAILED(rv) || available < REQUEST_RESUME_AT) { + self->mReceivedTooMuchData = false; + + // Post an event to verify if the request should be resumed. + if (NS_FAILED(self->mControlEventTarget->Dispatch( + NewRunnableMethod( + "BackgroundFileSaverStreamListener::NotifySuspendOrResume", + self, + &BackgroundFileSaverStreamListener::NotifySuspendOrResume), + NS_DISPATCH_NORMAL))) { + NS_WARNING("Unable to post resume event to the control thread."); + } + } + } +} + +// Called on the control thread. +nsresult BackgroundFileSaverStreamListener::NotifySuspendOrResume() { + // Prevent the worker thread from changing state while processing. + MutexAutoLock lock(mSuspensionLock); + + if (mReceivedTooMuchData) { + if (!mRequestSuspended) { + // Try to suspend the request. If this fails, don't try to resume later. + if (NS_SUCCEEDED(mRequest->Suspend())) { + mRequestSuspended = true; + } else { + NS_WARNING("Unable to suspend the request."); + } + } + } else { + if (mRequestSuspended) { + // Resume the request only if we succeeded in suspending it. + if (NS_SUCCEEDED(mRequest->Resume())) { + mRequestSuspended = false; + } else { + NS_WARNING("Unable to resume the request."); + } + } + } + + return NS_OK; +} + +//////////////////////////////////////////////////////////////////////////////// +//// DigestOutputStream +NS_IMPL_ISUPPORTS(DigestOutputStream, nsIOutputStream) + +DigestOutputStream::DigestOutputStream(nsIOutputStream* aStream, + Digest& aDigest) + : mOutputStream(aStream), mDigest(aDigest) { + MOZ_ASSERT(mOutputStream, "Can't have null output stream"); +} + +NS_IMETHODIMP +DigestOutputStream::Close() { return mOutputStream->Close(); } + +NS_IMETHODIMP +DigestOutputStream::Flush() { return mOutputStream->Flush(); } + +NS_IMETHODIMP +DigestOutputStream::Write(const char* aBuf, uint32_t aCount, uint32_t* retval) { + nsresult rv = mDigest.Update( + BitwiseCast<const unsigned char*, const char*>(aBuf), aCount); + NS_ENSURE_SUCCESS(rv, rv); + + return mOutputStream->Write(aBuf, aCount, retval); +} + +NS_IMETHODIMP +DigestOutputStream::WriteFrom(nsIInputStream* aFromStream, uint32_t aCount, + uint32_t* retval) { + // Not supported. We could read the stream to a buf, call DigestOp on the + // result, seek back and pass the stream on, but it's not worth it since our + // application (NS_AsyncCopy) doesn't invoke this on the sink. + MOZ_CRASH("DigestOutputStream::WriteFrom not implemented"); +} + +NS_IMETHODIMP +DigestOutputStream::WriteSegments(nsReadSegmentFun aReader, void* aClosure, + uint32_t aCount, uint32_t* retval) { + MOZ_CRASH("DigestOutputStream::WriteSegments not implemented"); +} + +NS_IMETHODIMP +DigestOutputStream::IsNonBlocking(bool* retval) { + return mOutputStream->IsNonBlocking(retval); +} + +#undef LOG_ENABLED + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/BackgroundFileSaver.h b/netwerk/base/BackgroundFileSaver.h new file mode 100644 index 0000000000..0ac247786f --- /dev/null +++ b/netwerk/base/BackgroundFileSaver.h @@ -0,0 +1,396 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=2 et sw=2 tw=80: */ +/* 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/. */ + +/** + * This file defines two implementations of the nsIBackgroundFileSaver + * interface. See the "test_backgroundfilesaver.js" file for usage examples. + */ + +#ifndef BackgroundFileSaver_h__ +#define BackgroundFileSaver_h__ + +#include "ScopedNSSTypes.h" +#include "mozilla/Mutex.h" +#include "nsCOMArray.h" +#include "nsCOMPtr.h" +#include "nsIAsyncOutputStream.h" +#include "nsIBackgroundFileSaver.h" +#include "nsIStreamListener.h" +#include "nsStreamUtils.h" +#include "nsString.h" + +class nsIAsyncInputStream; +class nsISerialEventTarget; + +namespace mozilla { +namespace net { + +class DigestOutputStream; + +//////////////////////////////////////////////////////////////////////////////// +//// BackgroundFileSaver + +class BackgroundFileSaver : public nsIBackgroundFileSaver { + public: + NS_DECL_NSIBACKGROUNDFILESAVER + + BackgroundFileSaver(); + + /** + * Initializes the pipe and the worker thread on XPCOM construction. + * + * This is called automatically by the XPCOM infrastructure, and if this + * fails, the factory will delete this object without returning a reference. + */ + nsresult Init(); + + /** + * Number of worker threads that are currently running. + */ + static uint32_t sThreadCount; + + /** + * Maximum number of worker threads reached during the current download + * session, used for telemetry. + * + * When there are no more worker threads running, we consider the download + * session finished, and this counter is reset. + */ + static uint32_t sTelemetryMaxThreadCount; + + protected: + virtual ~BackgroundFileSaver(); + + /** + * Thread that constructed this object. + */ + nsCOMPtr<nsIEventTarget> mControlEventTarget; + + /** + * Thread to which the actual input/output is delegated. + */ + nsCOMPtr<nsISerialEventTarget> mBackgroundET; + + /** + * Stream that receives data from derived classes. The received data will be + * available to the worker thread through mPipeInputStream. This is an + * instance of nsPipeOutputStream, not BackgroundFileSaverOutputStream. + */ + nsCOMPtr<nsIAsyncOutputStream> mPipeOutputStream; + + /** + * Used during initialization, determines if the pipe is created with an + * infinite buffer. An infinite buffer is required if the derived class + * implements nsIStreamListener, because this interface requires all the + * provided data to be consumed synchronously. + */ + virtual bool HasInfiniteBuffer() = 0; + + /** + * Used by derived classes if they need to be called back while copying. + */ + virtual nsAsyncCopyProgressFun GetProgressCallback() = 0; + + /** + * Stream used by the worker thread to read the data to be saved. + */ + nsCOMPtr<nsIAsyncInputStream> mPipeInputStream; + + private: + friend class NotifyTargetChangeRunnable; + + /** + * Matches the nsIBackgroundFileSaver::observer property. + * + * @remarks This is a strong reference so that JavaScript callers don't need + * to worry about keeping another reference to the observer. + */ + nsCOMPtr<nsIBackgroundFileSaverObserver> mObserver; + + ////////////////////////////////////////////////////////////////////////////// + //// Shared state between control and worker threads + + /** + * Protects the shared state between control and worker threads. This mutex + * is always locked for a very short time, never during input/output. + */ + mozilla::Mutex mLock; + + /** + * True if the worker thread is already waiting to process a change in state. + */ + bool mWorkerThreadAttentionRequested; + + /** + * True if the operation should finish as soon as possibile. + */ + bool mFinishRequested; + + /** + * True if the operation completed, with either success or failure. + */ + bool mComplete; + + /** + * Holds the current file saver status. This is a success status while the + * object is working correctly, and remains such if the operation completes + * successfully. This becomes an error status when an error occurs on the + * worker thread, or when the operation is canceled. + */ + nsresult mStatus; + + /** + * True if we should append data to the initial target file, instead of + * overwriting it. + */ + bool mAppend; + + /** + * This is set by the first SetTarget call on the control thread, and contains + * the target file name that will be used by the worker thread, as soon as it + * is possible to update mActualTarget and open the file. This is null if no + * target was ever assigned to this object. + */ + nsCOMPtr<nsIFile> mInitialTarget; + + /** + * This is set by the first SetTarget call on the control thread, and + * indicates whether mInitialTarget should be kept as partially completed, + * rather than deleted, if the operation fails or is canceled. + */ + bool mInitialTargetKeepPartial; + + /** + * This is set by subsequent SetTarget calls on the control thread, and + * contains the new target file name to which the worker thread will move the + * target file, as soon as it can be done. This is null if SetTarget was + * called only once, or no target was ever assigned to this object. + * + * The target file can be renamed multiple times, though only the most recent + * rename is guaranteed to be processed by the worker thread. + */ + nsCOMPtr<nsIFile> mRenamedTarget; + + /** + * This is set by subsequent SetTarget calls on the control thread, and + * indicates whether mRenamedTarget should be kept as partially completed, + * rather than deleted, if the operation fails or is canceled. + */ + bool mRenamedTargetKeepPartial; + + /** + * While NS_AsyncCopy is in progress, allows canceling it. Null otherwise. + * This is read by both threads but only written by the worker thread. + */ + nsCOMPtr<nsISupports> mAsyncCopyContext; + + /** + * The SHA 256 hash in raw bytes of the downloaded file. This is written + * by the worker thread but can be read on the main thread. + */ + nsCString mSha256; + + /** + * Whether or not to compute the hash. Must be set on the main thread before + * setTarget is called. + */ + bool mSha256Enabled; + + /** + * Store the signature info. + */ + nsTArray<nsTArray<nsTArray<uint8_t>>> mSignatureInfo; + + /** + * Whether or not to extract the signature. Must be set on the main thread + * before setTarget is called. + */ + bool mSignatureInfoEnabled; + + ////////////////////////////////////////////////////////////////////////////// + //// State handled exclusively by the worker thread + + /** + * Current target file associated to the input and output streams. + */ + nsCOMPtr<nsIFile> mActualTarget; + + /** + * Indicates whether mActualTarget should be kept as partially completed, + * rather than deleted, if the operation fails or is canceled. + */ + bool mActualTargetKeepPartial; + + /** + * Used to calculate the file hash. This keeps state across file renames and + * is lazily initialized in ProcessStateChange. + */ + Maybe<Digest> mDigest; + + ////////////////////////////////////////////////////////////////////////////// + //// Private methods + + /** + * Called when NS_AsyncCopy completes. + * + * @param aClosure + * Populated with a raw pointer to the BackgroundFileSaver object. + * @param aStatus + * Success or failure status specified when the copy was interrupted. + */ + static void AsyncCopyCallback(void* aClosure, nsresult aStatus); + + /** + * Called on the control thread after state changes, to ensure that the worker + * thread will process the state change appropriately. + * + * @param aShouldInterruptCopy + * If true, the current NS_AsyncCopy, if any, is canceled. + */ + nsresult GetWorkerThreadAttention(bool aShouldInterruptCopy); + + /** + * Event called on the worker thread to begin processing a state change. + */ + nsresult ProcessAttention(); + + /** + * Called by ProcessAttention to execute the operations corresponding to the + * state change. If this results in an error, ProcessAttention will force the + * entire operation to be aborted. + */ + nsresult ProcessStateChange(); + + /** + * Returns true if completion conditions are met on the worker thread. The + * first time this happens, posts the completion event to the control thread. + */ + bool CheckCompletion(); + + /** + * Event called on the control thread to indicate that file contents will now + * be saved to the specified file. + */ + nsresult NotifyTargetChange(nsIFile* aTarget); + + /** + * Event called on the control thread to send the final notification. + */ + nsresult NotifySaveComplete(); + + /** + * Verifies the signature of the binary at the specified file path and stores + * the signature data in mSignatureInfo. We extract only X.509 certificates, + * since that is what Google's Safebrowsing protocol specifies. + */ + nsresult ExtractSignatureInfo(const nsAString& filePath); +}; + +//////////////////////////////////////////////////////////////////////////////// +//// BackgroundFileSaverOutputStream + +class BackgroundFileSaverOutputStream : public BackgroundFileSaver, + public nsIAsyncOutputStream, + public nsIOutputStreamCallback { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIOUTPUTSTREAM + NS_DECL_NSIASYNCOUTPUTSTREAM + NS_DECL_NSIOUTPUTSTREAMCALLBACK + + BackgroundFileSaverOutputStream(); + + protected: + virtual bool HasInfiniteBuffer() override; + virtual nsAsyncCopyProgressFun GetProgressCallback() override; + + private: + ~BackgroundFileSaverOutputStream() = default; + + /** + * Original callback provided to our AsyncWait wrapper. + */ + nsCOMPtr<nsIOutputStreamCallback> mAsyncWaitCallback; +}; + +//////////////////////////////////////////////////////////////////////////////// +//// BackgroundFileSaverStreamListener. This class is instantiated by +// nsExternalHelperAppService, DownloadCore.jsm, and possibly others. + +class BackgroundFileSaverStreamListener final : public BackgroundFileSaver, + public nsIStreamListener { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIREQUESTOBSERVER + NS_DECL_NSISTREAMLISTENER + + BackgroundFileSaverStreamListener(); + + protected: + virtual bool HasInfiniteBuffer() override; + virtual nsAsyncCopyProgressFun GetProgressCallback() override; + + private: + ~BackgroundFileSaverStreamListener() = default; + + /** + * Protects the state related to whether the request should be suspended. + */ + mozilla::Mutex mSuspensionLock; + + /** + * Whether we should suspend the request because we received too much data. + */ + bool mReceivedTooMuchData; + + /** + * Request for which we received too much data. This is populated when + * mReceivedTooMuchData becomes true for the first time. + */ + nsCOMPtr<nsIRequest> mRequest; + + /** + * Whether mRequest is currently suspended. + */ + bool mRequestSuspended; + + /** + * Called while NS_AsyncCopy is copying data. + */ + static void AsyncCopyProgressCallback(void* aClosure, uint32_t aCount); + + /** + * Called on the control thread to suspend or resume the request. + */ + nsresult NotifySuspendOrResume(); +}; + +// A wrapper around nsIOutputStream, so that we can compute hashes on the +// stream without copying and without polluting pristine NSS code with XPCOM +// interfaces. +class DigestOutputStream : public nsIOutputStream { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIOUTPUTSTREAM + // Constructor. Neither parameter may be null. The caller owns both. + DigestOutputStream(nsIOutputStream* aStream, Digest& aDigest); + + private: + virtual ~DigestOutputStream() = default; + + // Calls to write are passed to this stream. + nsCOMPtr<nsIOutputStream> mOutputStream; + // Digest used to compute the hash, owned by the caller. + Digest& mDigest; + + // Don't accidentally copy construct. + DigestOutputStream(const DigestOutputStream& d) = delete; +}; + +} // namespace net +} // namespace mozilla + +#endif diff --git a/netwerk/base/CaptivePortalService.cpp b/netwerk/base/CaptivePortalService.cpp new file mode 100644 index 0000000000..6090a72a13 --- /dev/null +++ b/netwerk/base/CaptivePortalService.cpp @@ -0,0 +1,396 @@ +/* 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 "mozilla/net/CaptivePortalService.h" +#include "mozilla/ClearOnShutdown.h" +#include "mozilla/Services.h" +#include "mozilla/Preferences.h" +#include "nsIObserverService.h" +#include "nsServiceManagerUtils.h" +#include "nsXULAppAPI.h" +#include "xpcpublic.h" + +static constexpr auto kInterfaceName = u"captive-portal-inteface"_ns; + +static const char kOpenCaptivePortalLoginEvent[] = "captive-portal-login"; +static const char kAbortCaptivePortalLoginEvent[] = + "captive-portal-login-abort"; +static const char kCaptivePortalLoginSuccessEvent[] = + "captive-portal-login-success"; + +static const uint32_t kDefaultInterval = 60 * 1000; // check every 60 seconds + +namespace mozilla { +namespace net { + +static LazyLogModule gCaptivePortalLog("CaptivePortalService"); +#undef LOG +#define LOG(args) MOZ_LOG(gCaptivePortalLog, mozilla::LogLevel::Debug, args) + +NS_IMPL_ISUPPORTS(CaptivePortalService, nsICaptivePortalService, nsIObserver, + nsISupportsWeakReference, nsITimerCallback, + nsICaptivePortalCallback, nsINamed) + +static StaticRefPtr<CaptivePortalService> gCPService; + +// static +already_AddRefed<nsICaptivePortalService> CaptivePortalService::GetSingleton() { + if (gCPService) { + return do_AddRef(gCPService); + } + + gCPService = new CaptivePortalService(); + ClearOnShutdown(&gCPService); + return do_AddRef(gCPService); +} + +CaptivePortalService::CaptivePortalService() + : mState(UNKNOWN), + mStarted(false), + mInitialized(false), + mRequestInProgress(false), + mEverBeenCaptive(false), + mDelay(kDefaultInterval), + mSlackCount(0), + mMinInterval(kDefaultInterval), + mMaxInterval(25 * kDefaultInterval), + mBackoffFactor(5.0) { + mLastChecked = TimeStamp::Now(); +} + +CaptivePortalService::~CaptivePortalService() { + LOG(("CaptivePortalService::~CaptivePortalService isParentProcess:%d\n", + XRE_GetProcessType() == GeckoProcessType_Default)); +} + +nsresult CaptivePortalService::PerformCheck() { + LOG( + ("CaptivePortalService::PerformCheck mRequestInProgress:%d " + "mInitialized:%d mStarted:%d\n", + mRequestInProgress, mInitialized, mStarted)); + // Don't issue another request if last one didn't complete + if (mRequestInProgress || !mInitialized || !mStarted) { + return NS_OK; + } + MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default); + nsresult rv; + if (!mCaptivePortalDetector) { + mCaptivePortalDetector = + do_CreateInstance("@mozilla.org/toolkit/captive-detector;1", &rv); + if (NS_FAILED(rv)) { + LOG(("Unable to get a captive portal detector\n")); + return rv; + } + } + + LOG(("CaptivePortalService::PerformCheck - Calling CheckCaptivePortal\n")); + mRequestInProgress = true; + mCaptivePortalDetector->CheckCaptivePortal(kInterfaceName, this); + return NS_OK; +} + +nsresult CaptivePortalService::RearmTimer() { + LOG(("CaptivePortalService::RearmTimer\n")); + // Start a timer to recheck + MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default); + if (mTimer) { + mTimer->Cancel(); + } + + // If we have successfully determined the state, and we have never detected + // a captive portal, we don't need to keep polling, but will rely on events + // to trigger detection. + if (mState == NOT_CAPTIVE) { + return NS_OK; + } + + if (!mTimer) { + mTimer = NS_NewTimer(); + } + + if (mTimer && mDelay > 0) { + LOG(("CaptivePortalService - Reloading timer with delay %u\n", mDelay)); + return mTimer->InitWithCallback(this, mDelay, nsITimer::TYPE_ONE_SHOT); + } + + return NS_OK; +} + +nsresult CaptivePortalService::Initialize() { + if (mInitialized) { + return NS_OK; + } + mInitialized = true; + + // Only the main process service should actually do anything. The service in + // the content process only mirrors the CP state in the main process. + if (XRE_GetProcessType() != GeckoProcessType_Default) { + return NS_OK; + } + + nsCOMPtr<nsIObserverService> observerService = + mozilla::services::GetObserverService(); + if (observerService) { + observerService->AddObserver(this, kOpenCaptivePortalLoginEvent, true); + observerService->AddObserver(this, kAbortCaptivePortalLoginEvent, true); + observerService->AddObserver(this, kCaptivePortalLoginSuccessEvent, true); + } + + LOG(("Initialized CaptivePortalService\n")); + return NS_OK; +} + +nsresult CaptivePortalService::Start() { + if (!mInitialized) { + return NS_ERROR_NOT_INITIALIZED; + } + + if (xpc::AreNonLocalConnectionsDisabled() && + !Preferences::GetBool("network.captive-portal-service.testMode", false)) { + return NS_ERROR_NOT_AVAILABLE; + } + + if (XRE_GetProcessType() != GeckoProcessType_Default) { + // Doesn't do anything if called in the content process. + return NS_OK; + } + + if (mStarted) { + return NS_OK; + } + + MOZ_ASSERT(mState == UNKNOWN, "Initial state should be UNKNOWN"); + mStarted = true; + mEverBeenCaptive = false; + + // Get the delay prefs + Preferences::GetUint("network.captive-portal-service.minInterval", + &mMinInterval); + Preferences::GetUint("network.captive-portal-service.maxInterval", + &mMaxInterval); + Preferences::GetFloat("network.captive-portal-service.backoffFactor", + &mBackoffFactor); + + LOG(("CaptivePortalService::Start min:%u max:%u backoff:%.2f\n", mMinInterval, + mMaxInterval, mBackoffFactor)); + + mSlackCount = 0; + mDelay = mMinInterval; + + // When Start is called, perform a check immediately + PerformCheck(); + RearmTimer(); + return NS_OK; +} + +nsresult CaptivePortalService::Stop() { + LOG(("CaptivePortalService::Stop\n")); + + if (XRE_GetProcessType() != GeckoProcessType_Default) { + // Doesn't do anything when called in the content process. + return NS_OK; + } + + if (!mStarted) { + return NS_OK; + } + + if (mTimer) { + mTimer->Cancel(); + } + mTimer = nullptr; + mRequestInProgress = false; + mStarted = false; + mEverBeenCaptive = false; + if (mCaptivePortalDetector) { + mCaptivePortalDetector->Abort(kInterfaceName); + } + mCaptivePortalDetector = nullptr; + + // Clear the state in case anyone queries the state while detection is off. + mState = UNKNOWN; + return NS_OK; +} + +void CaptivePortalService::SetStateInChild(int32_t aState) { + // This should only be called in the content process, from ContentChild.cpp + // in order to mirror the captive portal state set in the chrome process. + MOZ_ASSERT(XRE_GetProcessType() != GeckoProcessType_Default); + + mState = aState; + mLastChecked = TimeStamp::Now(); +} + +//----------------------------------------------------------------------------- +// CaptivePortalService::nsICaptivePortalService +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +CaptivePortalService::GetState(int32_t* aState) { + *aState = mState; + return NS_OK; +} + +NS_IMETHODIMP +CaptivePortalService::RecheckCaptivePortal() { + LOG(("CaptivePortalService::RecheckCaptivePortal\n")); + + if (XRE_GetProcessType() != GeckoProcessType_Default) { + // Doesn't do anything if called in the content process. + return NS_OK; + } + + // This is called for user activity. We need to reset the slack count, + // so the checks continue to be quite frequent. + mSlackCount = 0; + mDelay = mMinInterval; + + PerformCheck(); + RearmTimer(); + return NS_OK; +} + +NS_IMETHODIMP +CaptivePortalService::GetLastChecked(uint64_t* aLastChecked) { + double duration = (TimeStamp::Now() - mLastChecked).ToMilliseconds(); + *aLastChecked = static_cast<uint64_t>(duration); + return NS_OK; +} + +//----------------------------------------------------------------------------- +// CaptivePortalService::nsITimer +// This callback gets called every mDelay miliseconds +// It issues a checkCaptivePortal operation if one isn't already in progress +//----------------------------------------------------------------------------- +NS_IMETHODIMP +CaptivePortalService::Notify(nsITimer* aTimer) { + LOG(("CaptivePortalService::Notify\n")); + MOZ_ASSERT(aTimer == mTimer); + MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default); + + PerformCheck(); + + // This is needed because we don't want to always make requests very often. + // Every 10 checks, we the delay is increased mBackoffFactor times + // to a maximum delay of mMaxInterval + mSlackCount++; + if (mSlackCount % 10 == 0) { + mDelay = mDelay * mBackoffFactor; + } + if (mDelay > mMaxInterval) { + mDelay = mMaxInterval; + } + + // Note - if mDelay is 0, the timer will not be rearmed. + RearmTimer(); + + return NS_OK; +} + +//----------------------------------------------------------------------------- +// CaptivePortalService::nsINamed +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +CaptivePortalService::GetName(nsACString& aName) { + aName.AssignLiteral("CaptivePortalService"); + return NS_OK; +} + +//----------------------------------------------------------------------------- +// CaptivePortalService::nsIObserver +//----------------------------------------------------------------------------- +NS_IMETHODIMP +CaptivePortalService::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) { + if (XRE_GetProcessType() != GeckoProcessType_Default) { + // Doesn't do anything if called in the content process. + return NS_OK; + } + + LOG(("CaptivePortalService::Observe() topic=%s\n", aTopic)); + if (!strcmp(aTopic, kOpenCaptivePortalLoginEvent)) { + // A redirect or altered content has been detected. + // The user needs to log in. We are in a captive portal. + mState = LOCKED_PORTAL; + mLastChecked = TimeStamp::Now(); + mEverBeenCaptive = true; + } else if (!strcmp(aTopic, kCaptivePortalLoginSuccessEvent)) { + // The user has successfully logged in. We have connectivity. + mState = UNLOCKED_PORTAL; + mLastChecked = TimeStamp::Now(); + mSlackCount = 0; + mDelay = mMinInterval; + + RearmTimer(); + } else if (!strcmp(aTopic, kAbortCaptivePortalLoginEvent)) { + // The login has been aborted + mState = UNKNOWN; + mLastChecked = TimeStamp::Now(); + mSlackCount = 0; + } + + // Send notification so that the captive portal state is mirrored in the + // content process. + nsCOMPtr<nsIObserverService> observerService = services::GetObserverService(); + if (observerService) { + nsCOMPtr<nsICaptivePortalService> cps(this); + observerService->NotifyObservers(cps, NS_IPC_CAPTIVE_PORTAL_SET_STATE, + nullptr); + } + + return NS_OK; +} + +void CaptivePortalService::NotifyConnectivityAvailable(bool aCaptive) { + nsCOMPtr<nsIObserverService> observerService = services::GetObserverService(); + if (observerService) { + nsCOMPtr<nsICaptivePortalService> cps(this); + observerService->NotifyObservers(cps, NS_CAPTIVE_PORTAL_CONNECTIVITY, + aCaptive ? u"captive" : u"clear"); + } +} + +//----------------------------------------------------------------------------- +// CaptivePortalService::nsICaptivePortalCallback +//----------------------------------------------------------------------------- +NS_IMETHODIMP +CaptivePortalService::Prepare() { + LOG(("CaptivePortalService::Prepare\n")); + MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default); + // XXX: Finish preparation shouldn't be called until dns and routing is + // available. + if (mCaptivePortalDetector) { + mCaptivePortalDetector->FinishPreparation(kInterfaceName); + } + return NS_OK; +} + +NS_IMETHODIMP +CaptivePortalService::Complete(bool success) { + LOG(("CaptivePortalService::Complete(success=%d) mState=%d\n", success, + mState)); + MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default); + mLastChecked = TimeStamp::Now(); + + // Note: this callback gets called when: + // 1. the request is completed, and content is valid (success == true) + // 2. when the request is aborted or times out (success == false) + + if (success) { + if (mEverBeenCaptive) { + mState = UNLOCKED_PORTAL; + NotifyConnectivityAvailable(true); + } else { + mState = NOT_CAPTIVE; + NotifyConnectivityAvailable(false); + } + } + + mRequestInProgress = false; + return NS_OK; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/CaptivePortalService.h b/netwerk/base/CaptivePortalService.h new file mode 100644 index 0000000000..9edd0752df --- /dev/null +++ b/netwerk/base/CaptivePortalService.h @@ -0,0 +1,75 @@ +/* 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/. */ + +#ifndef CaptivePortalService_h_ +#define CaptivePortalService_h_ + +#include "nsICaptivePortalService.h" +#include "nsICaptivePortalDetector.h" +#include "nsINamed.h" +#include "nsIObserver.h" +#include "nsWeakReference.h" +#include "nsITimer.h" +#include "nsCOMArray.h" +#include "mozilla/TimeStamp.h" + +namespace mozilla { +namespace net { + +class CaptivePortalService : public nsICaptivePortalService, + public nsIObserver, + public nsSupportsWeakReference, + public nsITimerCallback, + public nsICaptivePortalCallback, + public nsINamed { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSICAPTIVEPORTALSERVICE + NS_DECL_NSIOBSERVER + NS_DECL_NSITIMERCALLBACK + NS_DECL_NSICAPTIVEPORTALCALLBACK + NS_DECL_NSINAMED + + nsresult Initialize(); + nsresult Start(); + nsresult Stop(); + + static already_AddRefed<nsICaptivePortalService> GetSingleton(); + + // This method is only called in the content process, in order to mirror + // the captive portal state in the parent process. + void SetStateInChild(int32_t aState); + + private: + CaptivePortalService(); + virtual ~CaptivePortalService(); + nsresult PerformCheck(); + nsresult RearmTimer(); + void NotifyConnectivityAvailable(bool aCaptive); + + nsCOMPtr<nsICaptivePortalDetector> mCaptivePortalDetector; + int32_t mState; + + nsCOMPtr<nsITimer> mTimer; + bool mStarted; + bool mInitialized; + bool mRequestInProgress; + bool mEverBeenCaptive; + + uint32_t mDelay; + int32_t mSlackCount; + + uint32_t mMinInterval; + uint32_t mMaxInterval; + float mBackoffFactor; + + // This holds a timestamp when the last time when the captive portal check + // has changed state. + mozilla::TimeStamp mLastChecked; +}; + +} // namespace net +} // namespace mozilla + +#endif // CaptivePortalService_h_ diff --git a/netwerk/base/Dashboard.cpp b/netwerk/base/Dashboard.cpp new file mode 100644 index 0000000000..e775fbde1c --- /dev/null +++ b/netwerk/base/Dashboard.cpp @@ -0,0 +1,1186 @@ +/* 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 "mozilla/dom/NetDashboardBinding.h" +#include "mozilla/dom/ToJSValue.h" +#include "mozilla/ErrorNames.h" +#include "mozilla/net/Dashboard.h" +#include "mozilla/net/HttpInfo.h" +#include "mozilla/net/HTTPSSVC.h" +#include "mozilla/net/SocketProcessParent.h" +#include "nsHttp.h" +#include "nsICancelable.h" +#include "nsIDNSListener.h" +#include "nsIDNSService.h" +#include "nsIDNSRecord.h" +#include "nsIDNSByTypeRecord.h" +#include "nsIInputStream.h" +#include "nsINamed.h" +#include "nsINetAddr.h" +#include "nsISocketTransport.h" +#include "nsProxyRelease.h" +#include "nsSocketTransportService2.h" +#include "nsThreadUtils.h" +#include "nsURLHelper.h" +#include "mozilla/Logging.h" +#include "nsIOService.h" +#include "../cache2/CacheFileUtils.h" + +using mozilla::AutoSafeJSContext; +using mozilla::dom::Sequence; +using mozilla::dom::ToJSValue; + +namespace mozilla { +namespace net { + +class SocketData : public nsISupports { + public: + NS_DECL_THREADSAFE_ISUPPORTS + + SocketData() { + mTotalSent = 0; + mTotalRecv = 0; + mEventTarget = nullptr; + } + + uint64_t mTotalSent; + uint64_t mTotalRecv; + nsTArray<SocketInfo> mData; + nsMainThreadPtrHandle<nsINetDashboardCallback> mCallback; + nsIEventTarget* mEventTarget; + + private: + virtual ~SocketData() = default; +}; + +static void GetErrorString(nsresult rv, nsAString& errorString); + +NS_IMPL_ISUPPORTS0(SocketData) + +class HttpData : public nsISupports { + virtual ~HttpData() = default; + + public: + NS_DECL_THREADSAFE_ISUPPORTS + + HttpData() { mEventTarget = nullptr; } + + nsTArray<HttpRetParams> mData; + nsMainThreadPtrHandle<nsINetDashboardCallback> mCallback; + nsIEventTarget* mEventTarget; +}; + +NS_IMPL_ISUPPORTS0(HttpData) + +class WebSocketRequest : public nsISupports { + virtual ~WebSocketRequest() = default; + + public: + NS_DECL_THREADSAFE_ISUPPORTS + + WebSocketRequest() { mEventTarget = nullptr; } + + nsMainThreadPtrHandle<nsINetDashboardCallback> mCallback; + nsIEventTarget* mEventTarget; +}; + +NS_IMPL_ISUPPORTS0(WebSocketRequest) + +class DnsData : public nsISupports { + virtual ~DnsData() = default; + + public: + NS_DECL_THREADSAFE_ISUPPORTS + + DnsData() { mEventTarget = nullptr; } + + nsTArray<DNSCacheEntries> mData; + nsMainThreadPtrHandle<nsINetDashboardCallback> mCallback; + nsIEventTarget* mEventTarget; +}; + +NS_IMPL_ISUPPORTS0(DnsData) + +class ConnectionData : public nsITransportEventSink, + public nsITimerCallback, + public nsINamed { + virtual ~ConnectionData() { + if (mTimer) { + mTimer->Cancel(); + } + } + + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSITRANSPORTEVENTSINK + NS_DECL_NSITIMERCALLBACK + + NS_IMETHOD GetName(nsACString& aName) override { + aName.AssignLiteral("net::ConnectionData"); + return NS_OK; + } + + void StartTimer(uint32_t aTimeout); + void StopTimer(); + + explicit ConnectionData(Dashboard* target) : mPort(0), mTimeout(0) { + mEventTarget = nullptr; + mDashboard = target; + } + + nsCOMPtr<nsISocketTransport> mSocket; + nsCOMPtr<nsIInputStream> mStreamIn; + nsCOMPtr<nsITimer> mTimer; + nsMainThreadPtrHandle<nsINetDashboardCallback> mCallback; + nsIEventTarget* mEventTarget; + Dashboard* mDashboard; + + nsCString mHost; + uint32_t mPort; + nsCString mProtocol; + uint32_t mTimeout; + + nsString mStatus; +}; + +NS_IMPL_ISUPPORTS(ConnectionData, nsITransportEventSink, nsITimerCallback, + nsINamed) + +class RcwnData : public nsISupports { + virtual ~RcwnData() = default; + + public: + NS_DECL_THREADSAFE_ISUPPORTS + + RcwnData() { mEventTarget = nullptr; } + + nsMainThreadPtrHandle<nsINetDashboardCallback> mCallback; + nsIEventTarget* mEventTarget; +}; + +NS_IMPL_ISUPPORTS0(RcwnData) + +NS_IMETHODIMP +ConnectionData::OnTransportStatus(nsITransport* aTransport, nsresult aStatus, + int64_t aProgress, int64_t aProgressMax) { + if (aStatus == NS_NET_STATUS_CONNECTED_TO) { + StopTimer(); + } + + GetErrorString(aStatus, mStatus); + mEventTarget->Dispatch(NewRunnableMethod<RefPtr<ConnectionData>>( + "net::Dashboard::GetConnectionStatus", mDashboard, + &Dashboard::GetConnectionStatus, this), + NS_DISPATCH_NORMAL); + + return NS_OK; +} + +NS_IMETHODIMP +ConnectionData::Notify(nsITimer* aTimer) { + MOZ_ASSERT(aTimer == mTimer); + + if (mSocket) { + mSocket->Close(NS_ERROR_ABORT); + mSocket = nullptr; + mStreamIn = nullptr; + } + + mTimer = nullptr; + + mStatus.AssignLiteral(u"NS_ERROR_NET_TIMEOUT"); + mEventTarget->Dispatch(NewRunnableMethod<RefPtr<ConnectionData>>( + "net::Dashboard::GetConnectionStatus", mDashboard, + &Dashboard::GetConnectionStatus, this), + NS_DISPATCH_NORMAL); + + return NS_OK; +} + +void ConnectionData::StartTimer(uint32_t aTimeout) { + if (!mTimer) { + mTimer = NS_NewTimer(); + } + + mTimer->InitWithCallback(this, aTimeout * 1000, nsITimer::TYPE_ONE_SHOT); +} + +void ConnectionData::StopTimer() { + if (mTimer) { + mTimer->Cancel(); + mTimer = nullptr; + } +} + +class LookupHelper; + +class LookupArgument : public nsISupports { + virtual ~LookupArgument() = default; + + public: + NS_DECL_THREADSAFE_ISUPPORTS + + LookupArgument(nsIDNSRecord* aRecord, LookupHelper* aHelper) { + mRecord = aRecord; + mHelper = aHelper; + } + + nsCOMPtr<nsIDNSRecord> mRecord; + RefPtr<LookupHelper> mHelper; +}; + +NS_IMPL_ISUPPORTS0(LookupArgument) + +class LookupHelper final : public nsIDNSListener { + virtual ~LookupHelper() { + if (mCancel) { + mCancel->Cancel(NS_ERROR_ABORT); + } + } + + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIDNSLISTENER + + LookupHelper() : mEventTarget{nullptr}, mStatus{NS_ERROR_NOT_INITIALIZED} {} + + nsresult ConstructAnswer(LookupArgument* aArgument); + nsresult ConstructHTTPSRRAnswer(LookupArgument* aArgument); + + public: + nsCOMPtr<nsICancelable> mCancel; + nsMainThreadPtrHandle<nsINetDashboardCallback> mCallback; + nsIEventTarget* mEventTarget; + nsresult mStatus; +}; + +NS_IMPL_ISUPPORTS(LookupHelper, nsIDNSListener) + +NS_IMETHODIMP +LookupHelper::OnLookupComplete(nsICancelable* aRequest, nsIDNSRecord* aRecord, + nsresult aStatus) { + MOZ_ASSERT(aRequest == mCancel); + mCancel = nullptr; + mStatus = aStatus; + + nsCOMPtr<nsIDNSHTTPSSVCRecord> httpsRecord = do_QueryInterface(aRecord); + if (httpsRecord) { + RefPtr<LookupArgument> arg = new LookupArgument(aRecord, this); + mEventTarget->Dispatch( + NewRunnableMethod<RefPtr<LookupArgument>>( + "net::LookupHelper::ConstructHTTPSRRAnswer", this, + &LookupHelper::ConstructHTTPSRRAnswer, arg), + NS_DISPATCH_NORMAL); + return NS_OK; + } + + RefPtr<LookupArgument> arg = new LookupArgument(aRecord, this); + mEventTarget->Dispatch(NewRunnableMethod<RefPtr<LookupArgument>>( + "net::LookupHelper::ConstructAnswer", this, + &LookupHelper::ConstructAnswer, arg), + NS_DISPATCH_NORMAL); + + return NS_OK; +} + +nsresult LookupHelper::ConstructAnswer(LookupArgument* aArgument) { + nsIDNSRecord* aRecord = aArgument->mRecord; + AutoSafeJSContext cx; + + mozilla::dom::DNSLookupDict dict; + dict.mAddress.Construct(); + + Sequence<nsString>& addresses = dict.mAddress.Value(); + nsCOMPtr<nsIDNSAddrRecord> record = do_QueryInterface(aRecord); + if (NS_SUCCEEDED(mStatus) && record) { + dict.mAnswer = true; + bool hasMore; + record->HasMore(&hasMore); + while (hasMore) { + nsString* nextAddress = addresses.AppendElement(fallible); + if (!nextAddress) { + return NS_ERROR_OUT_OF_MEMORY; + } + + nsCString nextAddressASCII; + record->GetNextAddrAsString(nextAddressASCII); + CopyASCIItoUTF16(nextAddressASCII, *nextAddress); + record->HasMore(&hasMore); + } + } else { + dict.mAnswer = false; + GetErrorString(mStatus, dict.mError); + } + + JS::RootedValue val(cx); + if (!ToJSValue(cx, dict, &val)) { + return NS_ERROR_FAILURE; + } + + this->mCallback->OnDashboardDataAvailable(val); + + return NS_OK; +} + +static void CStringToHexString(const nsACString& aIn, nsAString& aOut) { + static const char* const lut = "0123456789ABCDEF"; + + size_t len = aIn.Length(); + + aOut.SetCapacity(2 * len); + for (size_t i = 0; i < aIn.Length(); ++i) { + const char c = static_cast<char>(aIn[i]); + aOut.Append(lut[(c >> 4) & 0x0F]); + aOut.Append(lut[c & 15]); + } +} + +nsresult LookupHelper::ConstructHTTPSRRAnswer(LookupArgument* aArgument) { + nsCOMPtr<nsIDNSHTTPSSVCRecord> httpsRecord = + do_QueryInterface(aArgument->mRecord); + + AutoSafeJSContext cx; + + mozilla::dom::HTTPSRRLookupDict dict; + dict.mRecords.Construct(); + + Sequence<dom::HTTPSRecord>& records = dict.mRecords.Value(); + if (NS_SUCCEEDED(mStatus) && httpsRecord) { + dict.mAnswer = true; + nsTArray<RefPtr<nsISVCBRecord>> svcbRecords; + httpsRecord->GetRecords(svcbRecords); + + for (const auto& record : svcbRecords) { + dom::HTTPSRecord* nextRecord = records.AppendElement(fallible); + if (!nextRecord) { + return NS_ERROR_OUT_OF_MEMORY; + } + + Unused << record->GetPriority(&nextRecord->mPriority); + nsCString name; + Unused << record->GetName(name); + CopyASCIItoUTF16(name, nextRecord->mTargetName); + + nsTArray<RefPtr<nsISVCParam>> values; + Unused << record->GetValues(values); + if (values.IsEmpty()) { + continue; + } + + for (const auto& value : values) { + uint16_t type; + Unused << value->GetType(&type); + switch (type) { + case SvcParamKeyAlpn: { + nextRecord->mAlpn.Construct(); + nextRecord->mAlpn.Value().mType = type; + nsCOMPtr<nsISVCParamAlpn> alpnParam = do_QueryInterface(value); + nsTArray<nsCString> alpn; + Unused << alpnParam->GetAlpn(alpn); + nsAutoCString alpnStr; + for (const auto& str : alpn) { + alpnStr.Append(str); + alpnStr.Append(','); + } + CopyASCIItoUTF16(Span(alpnStr.BeginReading(), alpnStr.Length() - 1), + nextRecord->mAlpn.Value().mAlpn); + break; + } + case SvcParamKeyNoDefaultAlpn: { + nextRecord->mNoDefaultAlpn.Construct(); + nextRecord->mNoDefaultAlpn.Value().mType = type; + break; + } + case SvcParamKeyPort: { + nextRecord->mPort.Construct(); + nextRecord->mPort.Value().mType = type; + nsCOMPtr<nsISVCParamPort> portParam = do_QueryInterface(value); + Unused << portParam->GetPort(&nextRecord->mPort.Value().mPort); + break; + } + case SvcParamKeyIpv4Hint: { + nextRecord->mIpv4Hint.Construct(); + nextRecord->mIpv4Hint.Value().mType = type; + nsCOMPtr<nsISVCParamIPv4Hint> ipv4Param = do_QueryInterface(value); + nsTArray<RefPtr<nsINetAddr>> ipv4Hint; + Unused << ipv4Param->GetIpv4Hint(ipv4Hint); + if (!ipv4Hint.IsEmpty()) { + nextRecord->mIpv4Hint.Value().mAddress.Construct(); + for (const auto& address : ipv4Hint) { + nsString* nextAddress = nextRecord->mIpv4Hint.Value() + .mAddress.Value() + .AppendElement(fallible); + if (!nextAddress) { + return NS_ERROR_OUT_OF_MEMORY; + } + + nsCString addressASCII; + Unused << address->GetAddress(addressASCII); + CopyASCIItoUTF16(addressASCII, *nextAddress); + } + } + break; + } + case SvcParamKeyIpv6Hint: { + nextRecord->mIpv6Hint.Construct(); + nextRecord->mIpv6Hint.Value().mType = type; + nsCOMPtr<nsISVCParamIPv6Hint> ipv6Param = do_QueryInterface(value); + nsTArray<RefPtr<nsINetAddr>> ipv6Hint; + Unused << ipv6Param->GetIpv6Hint(ipv6Hint); + if (!ipv6Hint.IsEmpty()) { + nextRecord->mIpv6Hint.Value().mAddress.Construct(); + for (const auto& address : ipv6Hint) { + nsString* nextAddress = nextRecord->mIpv6Hint.Value() + .mAddress.Value() + .AppendElement(fallible); + if (!nextAddress) { + return NS_ERROR_OUT_OF_MEMORY; + } + + nsCString addressASCII; + Unused << address->GetAddress(addressASCII); + CopyASCIItoUTF16(addressASCII, *nextAddress); + } + } + break; + } + case SvcParamKeyEchConfig: { + nextRecord->mEchConfig.Construct(); + nextRecord->mEchConfig.Value().mType = type; + nsCOMPtr<nsISVCParamEchConfig> echConfigParam = + do_QueryInterface(value); + nsCString echConfigStr; + Unused << echConfigParam->GetEchconfig(echConfigStr); + CStringToHexString(echConfigStr, + nextRecord->mEchConfig.Value().mEchConfig); + break; + } + case SvcParamKeyODoHConfig: { + nextRecord->mODoHConfig.Construct(); + nextRecord->mODoHConfig.Value().mType = type; + nsCOMPtr<nsISVCParamODoHConfig> ODoHConfigParam = + do_QueryInterface(value); + nsCString ODoHConfigStr; + Unused << ODoHConfigParam->GetODoHConfig(ODoHConfigStr); + CStringToHexString(ODoHConfigStr, + nextRecord->mODoHConfig.Value().mODoHConfig); + break; + } + default: + break; + } + } + } + } else { + dict.mAnswer = false; + GetErrorString(mStatus, dict.mError); + } + + JS::RootedValue val(cx); + if (!ToJSValue(cx, dict, &val)) { + return NS_ERROR_FAILURE; + } + + this->mCallback->OnDashboardDataAvailable(val); + + return NS_OK; +} + +NS_IMPL_ISUPPORTS(Dashboard, nsIDashboard, nsIDashboardEventNotifier) + +Dashboard::Dashboard() { mEnableLogging = false; } + +NS_IMETHODIMP +Dashboard::RequestSockets(nsINetDashboardCallback* aCallback) { + RefPtr<SocketData> socketData = new SocketData(); + socketData->mCallback = new nsMainThreadPtrHolder<nsINetDashboardCallback>( + "nsINetDashboardCallback", aCallback, true); + socketData->mEventTarget = GetCurrentEventTarget(); + + if (nsIOService::UseSocketProcess()) { + if (!gIOService->SocketProcessReady()) { + return NS_ERROR_NOT_AVAILABLE; + } + + RefPtr<Dashboard> self(this); + SocketProcessParent::GetSingleton()->SendGetSocketData()->Then( + GetMainThreadSerialEventTarget(), __func__, + [self{std::move(self)}, + socketData{std::move(socketData)}](SocketDataArgs&& args) { + socketData->mData.Assign(args.info()); + socketData->mTotalSent = args.totalSent(); + socketData->mTotalRecv = args.totalRecv(); + socketData->mEventTarget->Dispatch( + NewRunnableMethod<RefPtr<SocketData>>( + "net::Dashboard::GetSockets", self, &Dashboard::GetSockets, + socketData), + NS_DISPATCH_NORMAL); + }, + [self](const mozilla::ipc::ResponseRejectReason) {}); + return NS_OK; + } + + gSocketTransportService->Dispatch( + NewRunnableMethod<RefPtr<SocketData>>( + "net::Dashboard::GetSocketsDispatch", this, + &Dashboard::GetSocketsDispatch, socketData), + NS_DISPATCH_NORMAL); + return NS_OK; +} + +nsresult Dashboard::GetSocketsDispatch(SocketData* aSocketData) { + RefPtr<SocketData> socketData = aSocketData; + if (gSocketTransportService) { + gSocketTransportService->GetSocketConnections(&socketData->mData); + socketData->mTotalSent = gSocketTransportService->GetSentBytes(); + socketData->mTotalRecv = gSocketTransportService->GetReceivedBytes(); + } + socketData->mEventTarget->Dispatch( + NewRunnableMethod<RefPtr<SocketData>>("net::Dashboard::GetSockets", this, + &Dashboard::GetSockets, socketData), + NS_DISPATCH_NORMAL); + return NS_OK; +} + +nsresult Dashboard::GetSockets(SocketData* aSocketData) { + RefPtr<SocketData> socketData = aSocketData; + AutoSafeJSContext cx; + + mozilla::dom::SocketsDict dict; + dict.mSockets.Construct(); + dict.mSent = 0; + dict.mReceived = 0; + + Sequence<mozilla::dom::SocketElement>& sockets = dict.mSockets.Value(); + + uint32_t length = socketData->mData.Length(); + if (!sockets.SetCapacity(length, fallible)) { + JS_ReportOutOfMemory(cx); + return NS_ERROR_OUT_OF_MEMORY; + } + + for (uint32_t i = 0; i < socketData->mData.Length(); i++) { + dom::SocketElement& mSocket = *sockets.AppendElement(fallible); + CopyASCIItoUTF16(socketData->mData[i].host, mSocket.mHost); + mSocket.mPort = socketData->mData[i].port; + mSocket.mActive = socketData->mData[i].active; + mSocket.mTcp = socketData->mData[i].tcp; + mSocket.mSent = (double)socketData->mData[i].sent; + mSocket.mReceived = (double)socketData->mData[i].received; + dict.mSent += socketData->mData[i].sent; + dict.mReceived += socketData->mData[i].received; + } + + dict.mSent += socketData->mTotalSent; + dict.mReceived += socketData->mTotalRecv; + JS::RootedValue val(cx); + if (!ToJSValue(cx, dict, &val)) return NS_ERROR_FAILURE; + socketData->mCallback->OnDashboardDataAvailable(val); + + return NS_OK; +} + +NS_IMETHODIMP +Dashboard::RequestHttpConnections(nsINetDashboardCallback* aCallback) { + RefPtr<HttpData> httpData = new HttpData(); + httpData->mCallback = new nsMainThreadPtrHolder<nsINetDashboardCallback>( + "nsINetDashboardCallback", aCallback, true); + httpData->mEventTarget = GetCurrentEventTarget(); + + if (nsIOService::UseSocketProcess()) { + if (!gIOService->SocketProcessReady()) { + return NS_ERROR_NOT_AVAILABLE; + } + + RefPtr<Dashboard> self(this); + SocketProcessParent::GetSingleton()->SendGetHttpConnectionData()->Then( + GetMainThreadSerialEventTarget(), __func__, + [self{std::move(self)}, httpData](nsTArray<HttpRetParams>&& params) { + httpData->mData.Assign(std::move(params)); + self->GetHttpConnections(httpData); + httpData->mEventTarget->Dispatch( + NewRunnableMethod<RefPtr<HttpData>>( + "net::Dashboard::GetHttpConnections", self, + &Dashboard::GetHttpConnections, httpData), + NS_DISPATCH_NORMAL); + }, + [self](const mozilla::ipc::ResponseRejectReason) {}); + return NS_OK; + } + + gSocketTransportService->Dispatch(NewRunnableMethod<RefPtr<HttpData>>( + "net::Dashboard::GetHttpDispatch", this, + &Dashboard::GetHttpDispatch, httpData), + NS_DISPATCH_NORMAL); + return NS_OK; +} + +nsresult Dashboard::GetHttpDispatch(HttpData* aHttpData) { + RefPtr<HttpData> httpData = aHttpData; + HttpInfo::GetHttpConnectionData(&httpData->mData); + httpData->mEventTarget->Dispatch( + NewRunnableMethod<RefPtr<HttpData>>("net::Dashboard::GetHttpConnections", + this, &Dashboard::GetHttpConnections, + httpData), + NS_DISPATCH_NORMAL); + return NS_OK; +} + +nsresult Dashboard::GetHttpConnections(HttpData* aHttpData) { + RefPtr<HttpData> httpData = aHttpData; + AutoSafeJSContext cx; + + mozilla::dom::HttpConnDict dict; + dict.mConnections.Construct(); + + using mozilla::dom::HalfOpenInfoDict; + using mozilla::dom::HttpConnectionElement; + using mozilla::dom::HttpConnInfo; + Sequence<HttpConnectionElement>& connections = dict.mConnections.Value(); + + uint32_t length = httpData->mData.Length(); + if (!connections.SetCapacity(length, fallible)) { + JS_ReportOutOfMemory(cx); + return NS_ERROR_OUT_OF_MEMORY; + } + + for (uint32_t i = 0; i < httpData->mData.Length(); i++) { + HttpConnectionElement& connection = *connections.AppendElement(fallible); + + CopyASCIItoUTF16(httpData->mData[i].host, connection.mHost); + connection.mPort = httpData->mData[i].port; + CopyASCIItoUTF16(httpData->mData[i].httpVersion, connection.mHttpVersion); + connection.mSsl = httpData->mData[i].ssl; + + connection.mActive.Construct(); + connection.mIdle.Construct(); + connection.mHalfOpens.Construct(); + + Sequence<HttpConnInfo>& active = connection.mActive.Value(); + Sequence<HttpConnInfo>& idle = connection.mIdle.Value(); + Sequence<HalfOpenInfoDict>& halfOpens = connection.mHalfOpens.Value(); + + if (!active.SetCapacity(httpData->mData[i].active.Length(), fallible) || + !idle.SetCapacity(httpData->mData[i].idle.Length(), fallible) || + !halfOpens.SetCapacity(httpData->mData[i].halfOpens.Length(), + fallible)) { + JS_ReportOutOfMemory(cx); + return NS_ERROR_OUT_OF_MEMORY; + } + + for (uint32_t j = 0; j < httpData->mData[i].active.Length(); j++) { + HttpConnInfo& info = *active.AppendElement(fallible); + info.mRtt = httpData->mData[i].active[j].rtt; + info.mTtl = httpData->mData[i].active[j].ttl; + info.mProtocolVersion = httpData->mData[i].active[j].protocolVersion; + } + + for (uint32_t j = 0; j < httpData->mData[i].idle.Length(); j++) { + HttpConnInfo& info = *idle.AppendElement(fallible); + info.mRtt = httpData->mData[i].idle[j].rtt; + info.mTtl = httpData->mData[i].idle[j].ttl; + info.mProtocolVersion = httpData->mData[i].idle[j].protocolVersion; + } + + for (uint32_t j = 0; j < httpData->mData[i].halfOpens.Length(); j++) { + HalfOpenInfoDict& info = *halfOpens.AppendElement(fallible); + info.mSpeculative = httpData->mData[i].halfOpens[j].speculative; + } + } + + JS::RootedValue val(cx); + if (!ToJSValue(cx, dict, &val)) { + return NS_ERROR_FAILURE; + } + + httpData->mCallback->OnDashboardDataAvailable(val); + + return NS_OK; +} + +NS_IMETHODIMP +Dashboard::GetEnableLogging(bool* value) { + *value = mEnableLogging; + return NS_OK; +} + +NS_IMETHODIMP +Dashboard::SetEnableLogging(const bool value) { + mEnableLogging = value; + return NS_OK; +} + +NS_IMETHODIMP +Dashboard::AddHost(const nsACString& aHost, uint32_t aSerial, bool aEncrypted) { + if (mEnableLogging) { + mozilla::MutexAutoLock lock(mWs.lock); + LogData mData(nsCString(aHost), aSerial, aEncrypted); + if (mWs.data.Contains(mData)) { + return NS_OK; + } + // XXX(Bug 1631371) Check if this should use a fallible operation as it + // pretended earlier. + mWs.data.AppendElement(mData); + return NS_OK; + } + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP +Dashboard::RemoveHost(const nsACString& aHost, uint32_t aSerial) { + if (mEnableLogging) { + mozilla::MutexAutoLock lock(mWs.lock); + int32_t index = mWs.IndexOf(nsCString(aHost), aSerial); + if (index == -1) return NS_ERROR_FAILURE; + mWs.data.RemoveElementAt(index); + return NS_OK; + } + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP +Dashboard::NewMsgSent(const nsACString& aHost, uint32_t aSerial, + uint32_t aLength) { + if (mEnableLogging) { + mozilla::MutexAutoLock lock(mWs.lock); + int32_t index = mWs.IndexOf(nsCString(aHost), aSerial); + if (index == -1) return NS_ERROR_FAILURE; + mWs.data[index].mMsgSent++; + mWs.data[index].mSizeSent += aLength; + return NS_OK; + } + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP +Dashboard::NewMsgReceived(const nsACString& aHost, uint32_t aSerial, + uint32_t aLength) { + if (mEnableLogging) { + mozilla::MutexAutoLock lock(mWs.lock); + int32_t index = mWs.IndexOf(nsCString(aHost), aSerial); + if (index == -1) return NS_ERROR_FAILURE; + mWs.data[index].mMsgReceived++; + mWs.data[index].mSizeReceived += aLength; + return NS_OK; + } + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP +Dashboard::RequestWebsocketConnections(nsINetDashboardCallback* aCallback) { + RefPtr<WebSocketRequest> wsRequest = new WebSocketRequest(); + wsRequest->mCallback = new nsMainThreadPtrHolder<nsINetDashboardCallback>( + "nsINetDashboardCallback", aCallback, true); + wsRequest->mEventTarget = GetCurrentEventTarget(); + + wsRequest->mEventTarget->Dispatch( + NewRunnableMethod<RefPtr<WebSocketRequest>>( + "net::Dashboard::GetWebSocketConnections", this, + &Dashboard::GetWebSocketConnections, wsRequest), + NS_DISPATCH_NORMAL); + return NS_OK; +} + +nsresult Dashboard::GetWebSocketConnections(WebSocketRequest* aWsRequest) { + RefPtr<WebSocketRequest> wsRequest = aWsRequest; + AutoSafeJSContext cx; + + mozilla::dom::WebSocketDict dict; + dict.mWebsockets.Construct(); + Sequence<mozilla::dom::WebSocketElement>& websockets = + dict.mWebsockets.Value(); + + mozilla::MutexAutoLock lock(mWs.lock); + uint32_t length = mWs.data.Length(); + if (!websockets.SetCapacity(length, fallible)) { + JS_ReportOutOfMemory(cx); + return NS_ERROR_OUT_OF_MEMORY; + } + + for (uint32_t i = 0; i < mWs.data.Length(); i++) { + dom::WebSocketElement& websocket = *websockets.AppendElement(fallible); + CopyASCIItoUTF16(mWs.data[i].mHost, websocket.mHostport); + websocket.mMsgsent = mWs.data[i].mMsgSent; + websocket.mMsgreceived = mWs.data[i].mMsgReceived; + websocket.mSentsize = mWs.data[i].mSizeSent; + websocket.mReceivedsize = mWs.data[i].mSizeReceived; + websocket.mEncrypted = mWs.data[i].mEncrypted; + } + + JS::RootedValue val(cx); + if (!ToJSValue(cx, dict, &val)) { + return NS_ERROR_FAILURE; + } + wsRequest->mCallback->OnDashboardDataAvailable(val); + + return NS_OK; +} + +NS_IMETHODIMP +Dashboard::RequestDNSInfo(nsINetDashboardCallback* aCallback) { + RefPtr<DnsData> dnsData = new DnsData(); + dnsData->mCallback = new nsMainThreadPtrHolder<nsINetDashboardCallback>( + "nsINetDashboardCallback", aCallback, true); + + nsresult rv; + dnsData->mData.Clear(); + dnsData->mEventTarget = GetCurrentEventTarget(); + + if (!mDnsService) { + mDnsService = do_GetService("@mozilla.org/network/dns-service;1", &rv); + if (NS_FAILED(rv)) { + return rv; + } + } + + if (nsIOService::UseSocketProcess()) { + if (!gIOService->SocketProcessReady()) { + return NS_ERROR_NOT_AVAILABLE; + } + + RefPtr<Dashboard> self(this); + SocketProcessParent::GetSingleton()->SendGetDNSCacheEntries()->Then( + GetMainThreadSerialEventTarget(), __func__, + [self{std::move(self)}, + dnsData{std::move(dnsData)}](nsTArray<DNSCacheEntries>&& entries) { + dnsData->mData.Assign(std::move(entries)); + dnsData->mEventTarget->Dispatch( + NewRunnableMethod<RefPtr<DnsData>>( + "net::Dashboard::GetDNSCacheEntries", self, + &Dashboard::GetDNSCacheEntries, dnsData), + NS_DISPATCH_NORMAL); + }, + [self](const mozilla::ipc::ResponseRejectReason) {}); + return NS_OK; + } + + gSocketTransportService->Dispatch( + NewRunnableMethod<RefPtr<DnsData>>("net::Dashboard::GetDnsInfoDispatch", + this, &Dashboard::GetDnsInfoDispatch, + dnsData), + NS_DISPATCH_NORMAL); + return NS_OK; +} + +nsresult Dashboard::GetDnsInfoDispatch(DnsData* aDnsData) { + RefPtr<DnsData> dnsData = aDnsData; + if (mDnsService) { + mDnsService->GetDNSCacheEntries(&dnsData->mData); + } + dnsData->mEventTarget->Dispatch( + NewRunnableMethod<RefPtr<DnsData>>("net::Dashboard::GetDNSCacheEntries", + this, &Dashboard::GetDNSCacheEntries, + dnsData), + NS_DISPATCH_NORMAL); + return NS_OK; +} + +nsresult Dashboard::GetDNSCacheEntries(DnsData* dnsData) { + AutoSafeJSContext cx; + + mozilla::dom::DNSCacheDict dict; + dict.mEntries.Construct(); + Sequence<mozilla::dom::DnsCacheEntry>& entries = dict.mEntries.Value(); + + uint32_t length = dnsData->mData.Length(); + if (!entries.SetCapacity(length, fallible)) { + JS_ReportOutOfMemory(cx); + return NS_ERROR_OUT_OF_MEMORY; + } + + for (uint32_t i = 0; i < dnsData->mData.Length(); i++) { + dom::DnsCacheEntry& entry = *entries.AppendElement(fallible); + entry.mHostaddr.Construct(); + + Sequence<nsString>& addrs = entry.mHostaddr.Value(); + if (!addrs.SetCapacity(dnsData->mData[i].hostaddr.Length(), fallible)) { + JS_ReportOutOfMemory(cx); + return NS_ERROR_OUT_OF_MEMORY; + } + + CopyASCIItoUTF16(dnsData->mData[i].hostname, entry.mHostname); + entry.mExpiration = dnsData->mData[i].expiration; + entry.mTrr = dnsData->mData[i].TRR; + + for (uint32_t j = 0; j < dnsData->mData[i].hostaddr.Length(); j++) { + nsString* addr = addrs.AppendElement(fallible); + if (!addr) { + JS_ReportOutOfMemory(cx); + return NS_ERROR_OUT_OF_MEMORY; + } + CopyASCIItoUTF16(dnsData->mData[i].hostaddr[j], *addr); + } + + if (dnsData->mData[i].family == PR_AF_INET6) { + entry.mFamily.AssignLiteral(u"ipv6"); + } else { + entry.mFamily.AssignLiteral(u"ipv4"); + } + + entry.mOriginAttributesSuffix = + NS_ConvertUTF8toUTF16(dnsData->mData[i].originAttributesSuffix); + } + + JS::RootedValue val(cx); + if (!ToJSValue(cx, dict, &val)) { + return NS_ERROR_FAILURE; + } + dnsData->mCallback->OnDashboardDataAvailable(val); + + return NS_OK; +} + +NS_IMETHODIMP +Dashboard::RequestDNSLookup(const nsACString& aHost, + nsINetDashboardCallback* aCallback) { + nsresult rv; + + if (!mDnsService) { + mDnsService = do_GetService("@mozilla.org/network/dns-service;1", &rv); + if (NS_FAILED(rv)) { + return rv; + } + } + + RefPtr<LookupHelper> helper = new LookupHelper(); + helper->mCallback = new nsMainThreadPtrHolder<nsINetDashboardCallback>( + "nsINetDashboardCallback", aCallback, true); + helper->mEventTarget = GetCurrentEventTarget(); + OriginAttributes attrs; + rv = mDnsService->AsyncResolveNative( + aHost, nsIDNSService::RESOLVE_TYPE_DEFAULT, 0, nullptr, helper.get(), + NS_GetCurrentThread(), attrs, getter_AddRefs(helper->mCancel)); + return rv; +} + +NS_IMETHODIMP +Dashboard::RequestDNSHTTPSRRLookup(const nsACString& aHost, + nsINetDashboardCallback* aCallback) { + nsresult rv; + + if (!mDnsService) { + mDnsService = do_GetService("@mozilla.org/network/dns-service;1", &rv); + if (NS_FAILED(rv)) { + return rv; + } + } + + RefPtr<LookupHelper> helper = new LookupHelper(); + helper->mCallback = new nsMainThreadPtrHolder<nsINetDashboardCallback>( + "nsINetDashboardCallback", aCallback, true); + helper->mEventTarget = GetCurrentEventTarget(); + OriginAttributes attrs; + rv = mDnsService->AsyncResolveNative( + aHost, nsIDNSService::RESOLVE_TYPE_HTTPSSVC, 0, nullptr, helper.get(), + NS_GetCurrentThread(), attrs, getter_AddRefs(helper->mCancel)); + return rv; +} + +NS_IMETHODIMP +Dashboard::RequestRcwnStats(nsINetDashboardCallback* aCallback) { + RefPtr<RcwnData> rcwnData = new RcwnData(); + rcwnData->mEventTarget = GetCurrentEventTarget(); + rcwnData->mCallback = new nsMainThreadPtrHolder<nsINetDashboardCallback>( + "nsINetDashboardCallback", aCallback, true); + + return rcwnData->mEventTarget->Dispatch( + NewRunnableMethod<RefPtr<RcwnData>>("net::Dashboard::GetRcwnData", this, + &Dashboard::GetRcwnData, rcwnData), + NS_DISPATCH_NORMAL); +} + +nsresult Dashboard::GetRcwnData(RcwnData* aData) { + AutoSafeJSContext cx; + mozilla::dom::RcwnStatus dict; + + dict.mTotalNetworkRequests = gIOService->GetTotalRequestNumber(); + dict.mRcwnCacheWonCount = gIOService->GetCacheWonRequestNumber(); + dict.mRcwnNetWonCount = gIOService->GetNetWonRequestNumber(); + + uint32_t cacheSlow, cacheNotSlow; + CacheFileUtils::CachePerfStats::GetSlowStats(&cacheSlow, &cacheNotSlow); + dict.mCacheSlowCount = cacheSlow; + dict.mCacheNotSlowCount = cacheNotSlow; + + dict.mPerfStats.Construct(); + Sequence<mozilla::dom::RcwnPerfStats>& perfStats = dict.mPerfStats.Value(); + uint32_t length = CacheFileUtils::CachePerfStats::LAST; + if (!perfStats.SetCapacity(length, fallible)) { + JS_ReportOutOfMemory(cx); + return NS_ERROR_OUT_OF_MEMORY; + } + + for (uint32_t i = 0; i < length; i++) { + CacheFileUtils::CachePerfStats::EDataType perfType = + static_cast<CacheFileUtils::CachePerfStats::EDataType>(i); + dom::RcwnPerfStats& elem = *perfStats.AppendElement(fallible); + elem.mAvgShort = + CacheFileUtils::CachePerfStats::GetAverage(perfType, false); + elem.mAvgLong = CacheFileUtils::CachePerfStats::GetAverage(perfType, true); + elem.mStddevLong = + CacheFileUtils::CachePerfStats::GetStdDev(perfType, true); + } + + JS::RootedValue val(cx); + if (!ToJSValue(cx, dict, &val)) { + return NS_ERROR_FAILURE; + } + + aData->mCallback->OnDashboardDataAvailable(val); + + return NS_OK; +} + +void HttpConnInfo::SetHTTPProtocolVersion(HttpVersion pv) { + switch (pv) { + case HttpVersion::v0_9: + protocolVersion.AssignLiteral(u"http/0.9"); + break; + case HttpVersion::v1_0: + protocolVersion.AssignLiteral(u"http/1.0"); + break; + case HttpVersion::v1_1: + protocolVersion.AssignLiteral(u"http/1.1"); + break; + case HttpVersion::v2_0: + protocolVersion.AssignLiteral(u"http/2"); + break; + case HttpVersion::v3_0: + protocolVersion.AssignLiteral(u"http/3"); + break; + default: + protocolVersion.AssignLiteral(u"unknown protocol version"); + } +} + +NS_IMETHODIMP +Dashboard::GetLogPath(nsACString& aLogPath) { + aLogPath.SetLength(2048); + uint32_t len = LogModule::GetLogFile(aLogPath.BeginWriting(), 2048); + aLogPath.SetLength(len); + return NS_OK; +} + +NS_IMETHODIMP +Dashboard::RequestConnection(const nsACString& aHost, uint32_t aPort, + const char* aProtocol, uint32_t aTimeout, + nsINetDashboardCallback* aCallback) { + nsresult rv; + RefPtr<ConnectionData> connectionData = new ConnectionData(this); + connectionData->mHost = aHost; + connectionData->mPort = aPort; + connectionData->mProtocol = aProtocol; + connectionData->mTimeout = aTimeout; + + connectionData->mCallback = + new nsMainThreadPtrHolder<nsINetDashboardCallback>( + "nsINetDashboardCallback", aCallback, true); + connectionData->mEventTarget = GetCurrentEventTarget(); + + rv = TestNewConnection(connectionData); + if (NS_FAILED(rv)) { + mozilla::net::GetErrorString(rv, connectionData->mStatus); + connectionData->mEventTarget->Dispatch( + NewRunnableMethod<RefPtr<ConnectionData>>( + "net::Dashboard::GetConnectionStatus", this, + &Dashboard::GetConnectionStatus, connectionData), + NS_DISPATCH_NORMAL); + return rv; + } + + return NS_OK; +} + +nsresult Dashboard::GetConnectionStatus(ConnectionData* aConnectionData) { + RefPtr<ConnectionData> connectionData = aConnectionData; + AutoSafeJSContext cx; + + mozilla::dom::ConnStatusDict dict; + dict.mStatus = connectionData->mStatus; + + JS::RootedValue val(cx); + if (!ToJSValue(cx, dict, &val)) return NS_ERROR_FAILURE; + + connectionData->mCallback->OnDashboardDataAvailable(val); + + return NS_OK; +} + +nsresult Dashboard::TestNewConnection(ConnectionData* aConnectionData) { + RefPtr<ConnectionData> connectionData = aConnectionData; + + nsresult rv; + if (!connectionData->mHost.Length() || + !net_IsValidHostName(connectionData->mHost)) { + return NS_ERROR_UNKNOWN_HOST; + } + + if (connectionData->mProtocol.EqualsLiteral("ssl")) { + AutoTArray<nsCString, 1> socketTypes = {connectionData->mProtocol}; + rv = gSocketTransportService->CreateTransport( + socketTypes, connectionData->mHost, connectionData->mPort, nullptr, + getter_AddRefs(connectionData->mSocket)); + } else { + rv = gSocketTransportService->CreateTransport( + nsTArray<nsCString>(), connectionData->mHost, connectionData->mPort, + nullptr, getter_AddRefs(connectionData->mSocket)); + } + if (NS_FAILED(rv)) { + return rv; + } + + rv = connectionData->mSocket->SetEventSink(connectionData, + GetCurrentEventTarget()); + if (NS_FAILED(rv)) { + return rv; + } + + rv = connectionData->mSocket->OpenInputStream( + nsITransport::OPEN_BLOCKING, 0, 0, + getter_AddRefs(connectionData->mStreamIn)); + if (NS_FAILED(rv)) { + return rv; + } + + connectionData->StartTimer(connectionData->mTimeout); + + return rv; +} + +typedef struct { + nsresult key; + const char* error; +} ErrorEntry; + +#undef ERROR +#define ERROR(key, val) \ + { key, #key } + +ErrorEntry socketTransportStatuses[] = { + ERROR(NS_NET_STATUS_RESOLVING_HOST, FAILURE(3)), + ERROR(NS_NET_STATUS_RESOLVED_HOST, FAILURE(11)), + ERROR(NS_NET_STATUS_CONNECTING_TO, FAILURE(7)), + ERROR(NS_NET_STATUS_CONNECTED_TO, FAILURE(4)), + ERROR(NS_NET_STATUS_TLS_HANDSHAKE_STARTING, FAILURE(12)), + ERROR(NS_NET_STATUS_TLS_HANDSHAKE_ENDED, FAILURE(13)), + ERROR(NS_NET_STATUS_SENDING_TO, FAILURE(5)), + ERROR(NS_NET_STATUS_WAITING_FOR, FAILURE(10)), + ERROR(NS_NET_STATUS_RECEIVING_FROM, FAILURE(6)), +}; +#undef ERROR + +static void GetErrorString(nsresult rv, nsAString& errorString) { + for (auto& socketTransportStatus : socketTransportStatuses) { + if (socketTransportStatus.key == rv) { + errorString.AssignASCII(socketTransportStatus.error); + return; + } + } + nsAutoCString errorCString; + mozilla::GetErrorName(rv, errorCString); + CopyUTF8toUTF16(errorCString, errorString); +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/Dashboard.h b/netwerk/base/Dashboard.h new file mode 100644 index 0000000000..4179397b0f --- /dev/null +++ b/netwerk/base/Dashboard.h @@ -0,0 +1,91 @@ +/* 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/. */ + +#ifndef nsDashboard_h__ +#define nsDashboard_h__ + +#include "mozilla/Mutex.h" +#include "mozilla/net/DashboardTypes.h" +#include "nsIDashboard.h" +#include "nsIDashboardEventNotifier.h" + +class nsIDNSService; + +namespace mozilla { +namespace net { + +class SocketData; +class HttpData; +class DnsData; +class WebSocketRequest; +class ConnectionData; +class RcwnData; + +class Dashboard final : public nsIDashboard, public nsIDashboardEventNotifier { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIDASHBOARD + NS_DECL_NSIDASHBOARDEVENTNOTIFIER + + Dashboard(); + static const char* GetErrorString(nsresult rv); + nsresult GetConnectionStatus(ConnectionData* aConnectionData); + + private: + struct LogData { + LogData(nsCString host, uint32_t serial, bool encryption) + : mHost(host), + mSerial(serial), + mMsgSent(0), + mMsgReceived(0), + mSizeSent(0), + mSizeReceived(0), + mEncrypted(encryption) {} + nsCString mHost; + uint32_t mSerial; + uint32_t mMsgSent; + uint32_t mMsgReceived; + uint64_t mSizeSent; + uint64_t mSizeReceived; + bool mEncrypted; + bool operator==(const LogData& a) const { + return mHost.Equals(a.mHost) && (mSerial == a.mSerial); + } + }; + + struct WebSocketData { + WebSocketData() : lock("Dashboard.webSocketData") {} + uint32_t IndexOf(const nsCString& hostname, uint32_t mSerial) { + LogData temp(hostname, mSerial, false); + return data.IndexOf(temp); + } + nsTArray<LogData> data; + mozilla::Mutex lock; + }; + + bool mEnableLogging; + WebSocketData mWs; + + private: + virtual ~Dashboard() = default; + + nsresult GetSocketsDispatch(SocketData*); + nsresult GetHttpDispatch(HttpData*); + nsresult GetDnsInfoDispatch(DnsData*); + nsresult TestNewConnection(ConnectionData*); + + /* Helper methods that pass the JSON to the callback function. */ + nsresult GetSockets(SocketData*); + nsresult GetHttpConnections(HttpData*); + nsresult GetDNSCacheEntries(DnsData*); + nsresult GetWebSocketConnections(WebSocketRequest*); + nsresult GetRcwnData(RcwnData*); + + nsCOMPtr<nsIDNSService> mDnsService; +}; + +} // namespace net +} // namespace mozilla + +#endif // nsDashboard_h__ diff --git a/netwerk/base/DashboardTypes.h b/netwerk/base/DashboardTypes.h new file mode 100644 index 0000000000..80fdd68d9c --- /dev/null +++ b/netwerk/base/DashboardTypes.h @@ -0,0 +1,179 @@ +/* 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/. */ + +#ifndef mozilla_net_DashboardTypes_h_ +#define mozilla_net_DashboardTypes_h_ + +#include "ipc/IPCMessageUtils.h" +#include "ipc/IPCMessageUtilsSpecializations.h" +#include "nsHttp.h" +#include "nsString.h" +#include "nsTArray.h" + +namespace mozilla { +namespace net { + +struct SocketInfo { + nsCString host; + uint64_t sent; + uint64_t received; + uint16_t port; + bool active; + bool tcp; +}; + +inline bool operator==(const SocketInfo& a, const SocketInfo& b) { + return a.host == b.host && a.sent == b.sent && a.received == b.received && + a.port == b.port && a.active == b.active && a.tcp == b.tcp; +} + +struct HalfOpenSockets { + bool speculative; +}; + +struct DNSCacheEntries { + nsCString hostname; + nsTArray<nsCString> hostaddr; + uint16_t family; + int64_t expiration; + nsCString netInterface; + bool TRR; + nsCString originAttributesSuffix; +}; + +struct HttpConnInfo { + uint32_t ttl; + uint32_t rtt; + nsString protocolVersion; + + void SetHTTPProtocolVersion(HttpVersion pv); +}; + +struct HttpRetParams { + nsCString host; + CopyableTArray<HttpConnInfo> active; + CopyableTArray<HttpConnInfo> idle; + CopyableTArray<HalfOpenSockets> halfOpens; + uint32_t counter; + uint16_t port; + nsCString httpVersion; + bool ssl; +}; + +} // namespace net +} // namespace mozilla + +namespace IPC { + +template <> +struct ParamTraits<mozilla::net::SocketInfo> { + typedef mozilla::net::SocketInfo paramType; + + static void Write(Message* aMsg, const paramType& aParam) { + WriteParam(aMsg, aParam.host); + WriteParam(aMsg, aParam.sent); + WriteParam(aMsg, aParam.received); + WriteParam(aMsg, aParam.port); + WriteParam(aMsg, aParam.active); + WriteParam(aMsg, aParam.tcp); + } + + static bool Read(const Message* aMsg, PickleIterator* aIter, + paramType* aResult) { + return ReadParam(aMsg, aIter, &aResult->host) && + ReadParam(aMsg, aIter, &aResult->sent) && + ReadParam(aMsg, aIter, &aResult->received) && + ReadParam(aMsg, aIter, &aResult->port) && + ReadParam(aMsg, aIter, &aResult->active) && + ReadParam(aMsg, aIter, &aResult->tcp); + } +}; + +template <> +struct ParamTraits<mozilla::net::DNSCacheEntries> { + typedef mozilla::net::DNSCacheEntries paramType; + + static void Write(Message* aMsg, const paramType& aParam) { + WriteParam(aMsg, aParam.hostname); + WriteParam(aMsg, aParam.hostaddr); + WriteParam(aMsg, aParam.family); + WriteParam(aMsg, aParam.expiration); + WriteParam(aMsg, aParam.netInterface); + WriteParam(aMsg, aParam.TRR); + } + + static bool Read(const Message* aMsg, PickleIterator* aIter, + paramType* aResult) { + return ReadParam(aMsg, aIter, &aResult->hostname) && + ReadParam(aMsg, aIter, &aResult->hostaddr) && + ReadParam(aMsg, aIter, &aResult->family) && + ReadParam(aMsg, aIter, &aResult->expiration) && + ReadParam(aMsg, aIter, &aResult->netInterface) && + ReadParam(aMsg, aIter, &aResult->TRR); + } +}; + +template <> +struct ParamTraits<mozilla::net::HalfOpenSockets> { + typedef mozilla::net::HalfOpenSockets paramType; + + static void Write(Message* aMsg, const paramType& aParam) { + WriteParam(aMsg, aParam.speculative); + } + + static bool Read(const Message* aMsg, PickleIterator* aIter, + paramType* aResult) { + return ReadParam(aMsg, aIter, &aResult->speculative); + } +}; + +template <> +struct ParamTraits<mozilla::net::HttpConnInfo> { + typedef mozilla::net::HttpConnInfo paramType; + + static void Write(Message* aMsg, const paramType& aParam) { + WriteParam(aMsg, aParam.ttl); + WriteParam(aMsg, aParam.rtt); + WriteParam(aMsg, aParam.protocolVersion); + } + + static bool Read(const Message* aMsg, PickleIterator* aIter, + paramType* aResult) { + return ReadParam(aMsg, aIter, &aResult->ttl) && + ReadParam(aMsg, aIter, &aResult->rtt) && + ReadParam(aMsg, aIter, &aResult->protocolVersion); + } +}; + +template <> +struct ParamTraits<mozilla::net::HttpRetParams> { + typedef mozilla::net::HttpRetParams paramType; + + static void Write(Message* aMsg, const paramType& aParam) { + WriteParam(aMsg, aParam.host); + WriteParam(aMsg, aParam.active); + WriteParam(aMsg, aParam.idle); + WriteParam(aMsg, aParam.halfOpens); + WriteParam(aMsg, aParam.counter); + WriteParam(aMsg, aParam.port); + WriteParam(aMsg, aParam.httpVersion); + WriteParam(aMsg, aParam.ssl); + } + + static bool Read(const Message* aMsg, PickleIterator* aIter, + paramType* aResult) { + return ReadParam(aMsg, aIter, &aResult->host) && + ReadParam(aMsg, aIter, &aResult->active) && + ReadParam(aMsg, aIter, &aResult->idle) && + ReadParam(aMsg, aIter, &aResult->halfOpens) && + ReadParam(aMsg, aIter, &aResult->counter) && + ReadParam(aMsg, aIter, &aResult->port) && + ReadParam(aMsg, aIter, &aResult->httpVersion) && + ReadParam(aMsg, aIter, &aResult->ssl); + } +}; + +} // namespace IPC + +#endif // mozilla_net_DashboardTypes_h_ diff --git a/netwerk/base/DefaultURI.cpp b/netwerk/base/DefaultURI.cpp new file mode 100644 index 0000000000..a76925a732 --- /dev/null +++ b/netwerk/base/DefaultURI.cpp @@ -0,0 +1,534 @@ +/* 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 "DefaultURI.h" +#include "nsIClassInfoImpl.h" +#include "nsIObjectInputStream.h" +#include "nsIObjectOutputStream.h" +namespace mozilla { +namespace net { + +#define NS_DEFAULTURI_CID \ + { /* 04445aa0-fd27-4c99-bd41-6be6318ae92c */ \ + 0x04445aa0, 0xfd27, 0x4c99, { \ + 0xbd, 0x41, 0x6b, 0xe6, 0x31, 0x8a, 0xe9, 0x2c \ + } \ + } + +#define ASSIGN_AND_ADDREF_THIS(ptrToMutator) \ + do { \ + if (ptrToMutator) { \ + *(ptrToMutator) = do_AddRef(this).take(); \ + } \ + } while (0) + +static NS_DEFINE_CID(kDefaultURICID, NS_DEFAULTURI_CID); + +//---------------------------------------------------------------------------- +// nsIClassInfo +//---------------------------------------------------------------------------- + +NS_IMPL_CLASSINFO(DefaultURI, nullptr, nsIClassInfo::THREADSAFE, + NS_DEFAULTURI_CID) +// Empty CI getter. We only need nsIClassInfo for Serialization +NS_IMPL_CI_INTERFACE_GETTER0(DefaultURI) + +//---------------------------------------------------------------------------- +// nsISupports +//---------------------------------------------------------------------------- + +NS_IMPL_ADDREF(DefaultURI) +NS_IMPL_RELEASE(DefaultURI) +NS_INTERFACE_TABLE_HEAD(DefaultURI) + NS_INTERFACE_TABLE(DefaultURI, nsIURI, nsISerializable) + NS_INTERFACE_TABLE_TO_MAP_SEGUE + NS_IMPL_QUERY_CLASSINFO(DefaultURI) + if (aIID.Equals(kDefaultURICID)) { + foundInterface = static_cast<nsIURI*>(this); + } else + NS_INTERFACE_MAP_ENTRY(nsISizeOf) +NS_INTERFACE_MAP_END + +//---------------------------------------------------------------------------- +// nsISerializable +//---------------------------------------------------------------------------- + +NS_IMETHODIMP DefaultURI::Read(nsIObjectInputStream* aInputStream) { + MOZ_ASSERT_UNREACHABLE("Use nsIURIMutator.read() instead"); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP DefaultURI::Write(nsIObjectOutputStream* aOutputStream) { + nsAutoCString spec(mURL->Spec()); + return aOutputStream->WriteStringZ(spec.get()); +} + +//---------------------------------------------------------------------------- +// nsISizeOf +//---------------------------------------------------------------------------- + +size_t DefaultURI::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const { + return mURL->SizeOf(); +} + +size_t DefaultURI::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const { + return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf); +} + +//---------------------------------------------------------------------------- +// nsIURI +//---------------------------------------------------------------------------- + +NS_IMETHODIMP DefaultURI::GetSpec(nsACString& aSpec) { + aSpec = mURL->Spec(); + return NS_OK; +} + +NS_IMETHODIMP DefaultURI::GetPrePath(nsACString& aPrePath) { + aPrePath = mURL->PrePath(); + return NS_OK; +} + +NS_IMETHODIMP DefaultURI::GetScheme(nsACString& aScheme) { + aScheme = mURL->Scheme(); + return NS_OK; +} + +NS_IMETHODIMP DefaultURI::GetUserPass(nsACString& aUserPass) { + aUserPass = mURL->Username(); + nsAutoCString pass(mURL->Password()); + if (pass.IsEmpty()) { + return NS_OK; + } + aUserPass.Append(':'); + aUserPass.Append(pass); + return NS_OK; +} + +NS_IMETHODIMP DefaultURI::GetUsername(nsACString& aUsername) { + aUsername = mURL->Username(); + return NS_OK; +} + +NS_IMETHODIMP DefaultURI::GetPassword(nsACString& aPassword) { + aPassword = mURL->Password(); + return NS_OK; +} + +NS_IMETHODIMP DefaultURI::GetHostPort(nsACString& aHostPort) { + aHostPort = mURL->HostPort(); + return NS_OK; +} + +NS_IMETHODIMP DefaultURI::GetHost(nsACString& aHost) { + aHost = mURL->Host(); + + // Historically nsIURI.host has always returned an IPv6 address that isn't + // enclosed in brackets. Ideally we want to change that, but for the sake of + // consitency we'll leave it like that for the moment. + // Bug 1603199 should fix this. + if (StringBeginsWith(aHost, "["_ns) && StringEndsWith(aHost, "]"_ns) && + aHost.FindChar(':') != kNotFound) { + aHost = Substring(aHost, 1, aHost.Length() - 2); + } + return NS_OK; +} + +NS_IMETHODIMP DefaultURI::GetPort(int32_t* aPort) { + *aPort = mURL->Port(); + return NS_OK; +} + +NS_IMETHODIMP DefaultURI::GetPathQueryRef(nsACString& aPathQueryRef) { + aPathQueryRef = mURL->Path(); + return NS_OK; +} + +NS_IMETHODIMP DefaultURI::Equals(nsIURI* other, bool* _retval) { + RefPtr<DefaultURI> otherUri; + nsresult rv = other->QueryInterface(kDefaultURICID, getter_AddRefs(otherUri)); + if (NS_FAILED(rv)) { + *_retval = false; + return NS_OK; + } + + *_retval = mURL->Spec() == otherUri->mURL->Spec(); + return NS_OK; +} + +NS_IMETHODIMP DefaultURI::SchemeIs(const char* scheme, bool* _retval) { + *_retval = mURL->Scheme().Equals(scheme); + return NS_OK; +} + +NS_IMETHODIMP DefaultURI::Resolve(const nsACString& aRelativePath, + nsACString& aResult) { + nsAutoCString scheme; + nsresult rv = net_ExtractURLScheme(aRelativePath, scheme); + if (NS_SUCCEEDED(rv)) { + aResult = aRelativePath; + return NS_OK; + } + + // We try to create another URL with this one as its base. + RefPtr<MozURL> resolvedURL; + rv = MozURL::Init(getter_AddRefs(resolvedURL), aRelativePath, mURL); + if (NS_WARN_IF(NS_FAILED(rv))) { + // If parsing the relative url fails, we revert to the previous behaviour + // and just return the relative path. + aResult = aRelativePath; + return NS_OK; + } + + aResult = resolvedURL->Spec(); + return NS_OK; +} + +NS_IMETHODIMP DefaultURI::GetAsciiSpec(nsACString& aAsciiSpec) { + return GetSpec(aAsciiSpec); +} + +NS_IMETHODIMP DefaultURI::GetAsciiHostPort(nsACString& aAsciiHostPort) { + return GetHostPort(aAsciiHostPort); +} + +NS_IMETHODIMP DefaultURI::GetAsciiHost(nsACString& aAsciiHost) { + return GetHost(aAsciiHost); +} + +NS_IMETHODIMP DefaultURI::GetRef(nsACString& aRef) { + aRef = mURL->Ref(); + return NS_OK; +} + +NS_IMETHODIMP DefaultURI::EqualsExceptRef(nsIURI* other, bool* _retval) { + RefPtr<DefaultURI> otherUri; + nsresult rv = other->QueryInterface(kDefaultURICID, getter_AddRefs(otherUri)); + if (NS_FAILED(rv)) { + *_retval = false; + return NS_OK; + } + + *_retval = mURL->SpecNoRef().Equals(otherUri->mURL->SpecNoRef()); + return NS_OK; +} + +NS_IMETHODIMP DefaultURI::GetSpecIgnoringRef(nsACString& aSpecIgnoringRef) { + aSpecIgnoringRef = mURL->SpecNoRef(); + return NS_OK; +} + +NS_IMETHODIMP DefaultURI::GetHasRef(bool* aHasRef) { + *aHasRef = mURL->HasFragment(); + return NS_OK; +} + +NS_IMETHODIMP DefaultURI::GetFilePath(nsACString& aFilePath) { + aFilePath = mURL->FilePath(); + return NS_OK; +} + +NS_IMETHODIMP DefaultURI::GetQuery(nsACString& aQuery) { + aQuery = mURL->Query(); + return NS_OK; +} + +NS_IMETHODIMP DefaultURI::GetDisplayHost(nsACString& aDisplayHost) { + // At the moment it doesn't seem useful to decode the hostname if it happens + // to contain punycode. + return GetHost(aDisplayHost); +} + +NS_IMETHODIMP DefaultURI::GetDisplayHostPort(nsACString& aDisplayHostPort) { + // At the moment it doesn't seem useful to decode the hostname if it happens + // to contain punycode. + return GetHostPort(aDisplayHostPort); +} + +NS_IMETHODIMP DefaultURI::GetDisplaySpec(nsACString& aDisplaySpec) { + // At the moment it doesn't seem useful to decode the hostname if it happens + // to contain punycode. + return GetSpec(aDisplaySpec); +} + +NS_IMETHODIMP DefaultURI::GetDisplayPrePath(nsACString& aDisplayPrePath) { + // At the moment it doesn't seem useful to decode the hostname if it happens + // to contain punycode. + return GetPrePath(aDisplayPrePath); +} + +NS_IMETHODIMP DefaultURI::Mutate(nsIURIMutator** _retval) { + RefPtr<DefaultURI::Mutator> mutator = new DefaultURI::Mutator(); + mutator->Init(this); + mutator.forget(_retval); + return NS_OK; +} + +void DefaultURI::Serialize(ipc::URIParams& aParams) { + ipc::DefaultURIParams params; + params.spec() = mURL->Spec(); + aParams = params; +} + +//---------------------------------------------------------------------------- +// nsIURIMutator +//---------------------------------------------------------------------------- + +NS_IMPL_ADDREF(DefaultURI::Mutator) +NS_IMPL_RELEASE(DefaultURI::Mutator) +NS_IMETHODIMP DefaultURI::Mutator::QueryInterface(REFNSIID aIID, + void** aInstancePtr) { + NS_ASSERTION(aInstancePtr, "QueryInterface requires a non-NULL destination!"); + nsISupports* foundInterface = nullptr; + if (aIID.Equals(NS_GET_IID(nsIURI))) { + RefPtr<DefaultURI> defaultURI = new DefaultURI(); + mMutator->Finalize(getter_AddRefs(defaultURI->mURL)); + foundInterface = + static_cast<nsISupports*>(static_cast<nsIURI*>((defaultURI.get()))); + NS_ADDREF(foundInterface); + *aInstancePtr = foundInterface; + return NS_OK; + } + + if (aIID.Equals(NS_GET_IID(nsIURIMutator)) || + aIID.Equals(NS_GET_IID(nsISupports))) { + foundInterface = + static_cast<nsISupports*>(static_cast<nsIURIMutator*>(this)); + } else if (aIID.Equals(NS_GET_IID(nsIURISetters))) { + foundInterface = + static_cast<nsISupports*>(static_cast<nsIURISetters*>(this)); + } else if (aIID.Equals(NS_GET_IID(nsIURISetSpec))) { + foundInterface = + static_cast<nsISupports*>(static_cast<nsIURISetSpec*>(this)); + } else if (aIID.Equals(NS_GET_IID(nsISerializable))) { + foundInterface = + static_cast<nsISupports*>(static_cast<nsISerializable*>(this)); + } + + if (foundInterface) { + NS_ADDREF(foundInterface); + *aInstancePtr = foundInterface; + return NS_OK; + } + + return NS_NOINTERFACE; +} + +NS_IMETHODIMP DefaultURI::Mutator::Read(nsIObjectInputStream* aStream) { + nsAutoCString spec; + nsresult rv = aStream->ReadCString(spec); + if (NS_FAILED(rv)) { + return rv; + } + return SetSpec(spec, nullptr); +} + +NS_IMETHODIMP DefaultURI::Mutator::Deserialize( + const mozilla::ipc::URIParams& aParams) { + if (aParams.type() != ipc::URIParams::TDefaultURIParams) { + NS_ERROR("Received unknown parameters from the other process!"); + return NS_ERROR_FAILURE; + } + + const ipc::DefaultURIParams& params = aParams.get_DefaultURIParams(); + auto result = MozURL::Mutator::FromSpec(params.spec()); + if (result.isErr()) { + return result.unwrapErr(); + } + mMutator = Some(result.unwrap()); + return NS_OK; +} + +NS_IMETHODIMP DefaultURI::Mutator::Finalize(nsIURI** aURI) { + if (!mMutator.isSome()) { + return NS_ERROR_NOT_AVAILABLE; + } + RefPtr<DefaultURI> uri = new DefaultURI(); + mMutator->Finalize(getter_AddRefs(uri->mURL)); + mMutator = Nothing(); + uri.forget(aURI); + return NS_OK; +} + +NS_IMETHODIMP DefaultURI::Mutator::SetSpec(const nsACString& aSpec, + nsIURIMutator** aMutator) { + ASSIGN_AND_ADDREF_THIS(aMutator); + auto result = MozURL::Mutator::FromSpec(aSpec); + if (result.isErr()) { + return result.unwrapErr(); + } + mMutator = Some(result.unwrap()); + return NS_OK; +} + +NS_IMETHODIMP +DefaultURI::Mutator::SetScheme(const nsACString& aScheme, + nsIURIMutator** aMutator) { + ASSIGN_AND_ADDREF_THIS(aMutator); + if (!mMutator.isSome()) { + return NS_ERROR_NULL_POINTER; + } + mMutator->SetScheme(aScheme); + return mMutator->GetStatus(); +} + +NS_IMETHODIMP +DefaultURI::Mutator::SetUserPass(const nsACString& aUserPass, + nsIURIMutator** aMutator) { + ASSIGN_AND_ADDREF_THIS(aMutator); + if (!mMutator.isSome()) { + return NS_ERROR_NULL_POINTER; + } + int32_t index = aUserPass.FindChar(':'); + if (index == kNotFound) { + mMutator->SetUsername(aUserPass); + mMutator->SetPassword(""_ns); + return mMutator->GetStatus(); + } + + mMutator->SetUsername(Substring(aUserPass, 0, index)); + nsresult rv = mMutator->GetStatus(); + if (NS_FAILED(rv)) { + return rv; + } + mMutator->SetPassword(Substring(aUserPass, index + 1)); + rv = mMutator->GetStatus(); + if (NS_FAILED(rv)) { + return rv; + } + return NS_OK; +} + +NS_IMETHODIMP +DefaultURI::Mutator::SetUsername(const nsACString& aUsername, + nsIURIMutator** aMutator) { + ASSIGN_AND_ADDREF_THIS(aMutator); + if (!mMutator.isSome()) { + return NS_ERROR_NULL_POINTER; + } + mMutator->SetUsername(aUsername); + return mMutator->GetStatus(); +} + +NS_IMETHODIMP +DefaultURI::Mutator::SetPassword(const nsACString& aPassword, + nsIURIMutator** aMutator) { + ASSIGN_AND_ADDREF_THIS(aMutator); + if (!mMutator.isSome()) { + return NS_ERROR_NULL_POINTER; + } + mMutator->SetPassword(aPassword); + return mMutator->GetStatus(); +} + +NS_IMETHODIMP +DefaultURI::Mutator::SetHostPort(const nsACString& aHostPort, + nsIURIMutator** aMutator) { + ASSIGN_AND_ADDREF_THIS(aMutator); + if (!mMutator.isSome()) { + return NS_ERROR_NULL_POINTER; + } + mMutator->SetHostPort(aHostPort); + return mMutator->GetStatus(); +} + +NS_IMETHODIMP +DefaultURI::Mutator::SetHost(const nsACString& aHost, + nsIURIMutator** aMutator) { + ASSIGN_AND_ADDREF_THIS(aMutator); + if (!mMutator.isSome()) { + return NS_ERROR_NULL_POINTER; + } + mMutator->SetHostname(aHost); + return mMutator->GetStatus(); +} + +NS_IMETHODIMP +DefaultURI::Mutator::SetPort(int32_t aPort, nsIURIMutator** aMutator) { + ASSIGN_AND_ADDREF_THIS(aMutator); + if (!mMutator.isSome()) { + return NS_ERROR_NULL_POINTER; + } + mMutator->SetPort(aPort); + return mMutator->GetStatus(); +} + +NS_IMETHODIMP +DefaultURI::Mutator::SetPathQueryRef(const nsACString& aPathQueryRef, + nsIURIMutator** aMutator) { + ASSIGN_AND_ADDREF_THIS(aMutator); + if (!mMutator.isSome()) { + return NS_ERROR_NULL_POINTER; + } + if (aPathQueryRef.IsEmpty()) { + mMutator->SetFilePath(""_ns); + mMutator->SetQuery(""_ns); + mMutator->SetRef(""_ns); + return mMutator->GetStatus(); + } + + nsAutoCString pathQueryRef(aPathQueryRef); + if (!StringBeginsWith(pathQueryRef, "/"_ns)) { + pathQueryRef.Insert('/', 0); + } + + RefPtr<MozURL> url; + mMutator->Finalize(getter_AddRefs(url)); + mMutator = Nothing(); + + auto result = MozURL::Mutator::FromSpec(pathQueryRef, url); + if (result.isErr()) { + return result.unwrapErr(); + } + mMutator = Some(result.unwrap()); + return mMutator->GetStatus(); +} + +NS_IMETHODIMP +DefaultURI::Mutator::SetRef(const nsACString& aRef, nsIURIMutator** aMutator) { + ASSIGN_AND_ADDREF_THIS(aMutator); + if (!mMutator.isSome()) { + return NS_ERROR_NULL_POINTER; + } + mMutator->SetRef(aRef); + return mMutator->GetStatus(); +} + +NS_IMETHODIMP +DefaultURI::Mutator::SetFilePath(const nsACString& aFilePath, + nsIURIMutator** aMutator) { + ASSIGN_AND_ADDREF_THIS(aMutator); + if (!mMutator.isSome()) { + return NS_ERROR_NULL_POINTER; + } + mMutator->SetFilePath(aFilePath); + return mMutator->GetStatus(); +} + +NS_IMETHODIMP +DefaultURI::Mutator::SetQuery(const nsACString& aQuery, + nsIURIMutator** aMutator) { + ASSIGN_AND_ADDREF_THIS(aMutator); + if (!mMutator.isSome()) { + return NS_ERROR_NULL_POINTER; + } + mMutator->SetQuery(aQuery); + return mMutator->GetStatus(); +} + +NS_IMETHODIMP +DefaultURI::Mutator::SetQueryWithEncoding(const nsACString& aQuery, + const mozilla::Encoding* aEncoding, + nsIURIMutator** aMutator) { + ASSIGN_AND_ADDREF_THIS(aMutator); + if (!mMutator.isSome()) { + return NS_ERROR_NULL_POINTER; + } + // we only support UTF-8 for DefaultURI + mMutator->SetQuery(aQuery); + return mMutator->GetStatus(); +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/DefaultURI.h b/netwerk/base/DefaultURI.h new file mode 100644 index 0000000000..e737067565 --- /dev/null +++ b/netwerk/base/DefaultURI.h @@ -0,0 +1,59 @@ +/* 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/. */ + +#ifndef DefaultURI_h__ +#define DefaultURI_h__ + +#include "nsIURI.h" +#include "nsISerializable.h" +#include "nsISizeOf.h" +#include "nsIURIMutator.h" +#include "mozilla/net/MozURL.h" + +namespace mozilla { +namespace net { + +class DefaultURI : public nsIURI, public nsISerializable, public nsISizeOf { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIURI + NS_DECL_NSISERIALIZABLE + + virtual size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const override; + virtual size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const override; + + class Mutator final : public nsIURIMutator, public nsISerializable { + NS_DECL_ISUPPORTS + NS_DECL_NSIURISETSPEC + NS_DECL_NSIURISETTERS + NS_DECL_NSIURIMUTATOR + + NS_IMETHOD + Write(nsIObjectOutputStream* aOutputStream) override { + MOZ_ASSERT_UNREACHABLE("nsIURIMutator.write() should never be called"); + return NS_ERROR_NOT_IMPLEMENTED; + } + + [[nodiscard]] NS_IMETHOD Read(nsIObjectInputStream* aStream) override; + + explicit Mutator() = default; + + private: + virtual ~Mutator() = default; + void Init(DefaultURI* aFrom) { mMutator = Some(aFrom->mURL->Mutate()); } + + Maybe<MozURL::Mutator> mMutator; + + friend class DefaultURI; + }; + + private: + virtual ~DefaultURI() = default; + RefPtr<MozURL> mURL; +}; + +} // namespace net +} // namespace mozilla + +#endif // DefaultURI_h__ diff --git a/netwerk/base/EventTokenBucket.cpp b/netwerk/base/EventTokenBucket.cpp new file mode 100644 index 0000000000..af902801c3 --- /dev/null +++ b/netwerk/base/EventTokenBucket.cpp @@ -0,0 +1,407 @@ +/* -*- 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 "EventTokenBucket.h" + +#include "nsICancelable.h" +#include "nsIIOService.h" +#include "nsNetCID.h" +#include "nsNetUtil.h" +#include "nsServiceManagerUtils.h" +#include "nsSocketTransportService2.h" +#ifdef DEBUG +# include "MainThreadUtils.h" +#endif + +#ifdef XP_WIN +# include <windows.h> +# include <mmsystem.h> +#endif + +namespace mozilla { +namespace net { + +//////////////////////////////////////////// +// EventTokenBucketCancelable +//////////////////////////////////////////// + +class TokenBucketCancelable : public nsICancelable { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSICANCELABLE + + explicit TokenBucketCancelable(class ATokenBucketEvent* event); + void Fire(); + + private: + virtual ~TokenBucketCancelable() = default; + + friend class EventTokenBucket; + ATokenBucketEvent* mEvent; +}; + +NS_IMPL_ISUPPORTS(TokenBucketCancelable, nsICancelable) + +TokenBucketCancelable::TokenBucketCancelable(ATokenBucketEvent* event) + : mEvent(event) {} + +NS_IMETHODIMP +TokenBucketCancelable::Cancel(nsresult reason) { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + mEvent = nullptr; + return NS_OK; +} + +void TokenBucketCancelable::Fire() { + if (!mEvent) return; + + ATokenBucketEvent* event = mEvent; + mEvent = nullptr; + event->OnTokenBucketAdmitted(); +} + +//////////////////////////////////////////// +// EventTokenBucket +//////////////////////////////////////////// + +NS_IMPL_ISUPPORTS(EventTokenBucket, nsITimerCallback, nsINamed) + +// by default 1hz with no burst +EventTokenBucket::EventTokenBucket(uint32_t eventsPerSecond, uint32_t burstSize) + : mUnitCost(kUsecPerSec), + mMaxCredit(kUsecPerSec), + mCredit(kUsecPerSec), + mPaused(false), + mStopped(false), + mTimerArmed(false) +#ifdef XP_WIN + , + mFineGrainTimerInUse(false), + mFineGrainResetTimerArmed(false) +#endif +{ + mLastUpdate = TimeStamp::Now(); + + MOZ_ASSERT(NS_IsMainThread()); + + nsresult rv; + nsCOMPtr<nsIEventTarget> sts; + nsCOMPtr<nsIIOService> ioService = do_GetIOService(&rv); + if (NS_SUCCEEDED(rv)) + sts = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv); + if (NS_SUCCEEDED(rv)) mTimer = NS_NewTimer(sts); + SetRate(eventsPerSecond, burstSize); +} + +EventTokenBucket::~EventTokenBucket() { + SOCKET_LOG( + ("EventTokenBucket::dtor %p events=%zu\n", this, mEvents.GetSize())); + + CleanupTimers(); + + // Complete any queued events to prevent hangs + while (mEvents.GetSize()) { + RefPtr<TokenBucketCancelable> cancelable = mEvents.PopFront(); + cancelable->Fire(); + } +} + +void EventTokenBucket::CleanupTimers() { + if (mTimer && mTimerArmed) { + mTimer->Cancel(); + } + mTimer = nullptr; + mTimerArmed = false; + +#ifdef XP_WIN + NormalTimers(); + if (mFineGrainResetTimer && mFineGrainResetTimerArmed) { + mFineGrainResetTimer->Cancel(); + } + mFineGrainResetTimer = nullptr; + mFineGrainResetTimerArmed = false; +#endif +} + +void EventTokenBucket::SetRate(uint32_t eventsPerSecond, uint32_t burstSize) { + SOCKET_LOG(("EventTokenBucket::SetRate %p %u %u\n", this, eventsPerSecond, + burstSize)); + + if (eventsPerSecond > kMaxHz) { + eventsPerSecond = kMaxHz; + SOCKET_LOG((" eventsPerSecond out of range\n")); + } + + if (!eventsPerSecond) { + eventsPerSecond = 1; + SOCKET_LOG((" eventsPerSecond out of range\n")); + } + + mUnitCost = kUsecPerSec / eventsPerSecond; + mMaxCredit = mUnitCost * burstSize; + if (mMaxCredit > kUsecPerSec * 60 * 15) { + SOCKET_LOG((" burstSize out of range\n")); + mMaxCredit = kUsecPerSec * 60 * 15; + } + mCredit = mMaxCredit; + mLastUpdate = TimeStamp::Now(); +} + +void EventTokenBucket::ClearCredits() { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + SOCKET_LOG(("EventTokenBucket::ClearCredits %p\n", this)); + mCredit = 0; +} + +uint32_t EventTokenBucket::BurstEventsAvailable() { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + return static_cast<uint32_t>(mCredit / mUnitCost); +} + +uint32_t EventTokenBucket::QueuedEvents() { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + return mEvents.GetSize(); +} + +void EventTokenBucket::Pause() { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + SOCKET_LOG(("EventTokenBucket::Pause %p\n", this)); + if (mPaused || mStopped) return; + + mPaused = true; + if (mTimerArmed) { + mTimer->Cancel(); + mTimerArmed = false; + } +} + +void EventTokenBucket::UnPause() { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + SOCKET_LOG(("EventTokenBucket::UnPause %p\n", this)); + if (!mPaused || mStopped) return; + + mPaused = false; + DispatchEvents(); + UpdateTimer(); +} + +void EventTokenBucket::Stop() { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + SOCKET_LOG(("EventTokenBucket::Stop %p armed=%d\n", this, mTimerArmed)); + mStopped = true; + CleanupTimers(); + + // Complete any queued events to prevent hangs + while (mEvents.GetSize()) { + RefPtr<TokenBucketCancelable> cancelable = mEvents.PopFront(); + cancelable->Fire(); + } +} + +nsresult EventTokenBucket::SubmitEvent(ATokenBucketEvent* event, + nsICancelable** cancelable) { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + SOCKET_LOG(("EventTokenBucket::SubmitEvent %p\n", this)); + + if (mStopped || !mTimer) return NS_ERROR_FAILURE; + + UpdateCredits(); + + RefPtr<TokenBucketCancelable> cancelEvent = new TokenBucketCancelable(event); + // When this function exits the cancelEvent needs 2 references, one for the + // mEvents queue and one for the caller of SubmitEvent() + + *cancelable = do_AddRef(cancelEvent).take(); + + if (mPaused || !TryImmediateDispatch(cancelEvent.get())) { + // queue it + SOCKET_LOG((" queued\n")); + mEvents.Push(cancelEvent.forget()); + UpdateTimer(); + } else { + SOCKET_LOG((" dispatched synchronously\n")); + } + + return NS_OK; +} + +bool EventTokenBucket::TryImmediateDispatch(TokenBucketCancelable* cancelable) { + if (mCredit < mUnitCost) return false; + + mCredit -= mUnitCost; + cancelable->Fire(); + return true; +} + +void EventTokenBucket::DispatchEvents() { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + SOCKET_LOG(("EventTokenBucket::DispatchEvents %p %d\n", this, mPaused)); + if (mPaused || mStopped) return; + + while (mEvents.GetSize() && mUnitCost <= mCredit) { + RefPtr<TokenBucketCancelable> cancelable = mEvents.PopFront(); + if (cancelable->mEvent) { + SOCKET_LOG( + ("EventTokenBucket::DispachEvents [%p] " + "Dispatching queue token bucket event cost=%" PRIu64 + " credit=%" PRIu64 "\n", + this, mUnitCost, mCredit)); + mCredit -= mUnitCost; + cancelable->Fire(); + } + } + +#ifdef XP_WIN + if (!mEvents.GetSize()) WantNormalTimers(); +#endif +} + +void EventTokenBucket::UpdateTimer() { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + if (mTimerArmed || mPaused || mStopped || !mEvents.GetSize() || !mTimer) + return; + + if (mCredit >= mUnitCost) return; + + // determine the time needed to wait to accumulate enough credits to admit + // one more event and set the timer for that point. Always round it + // up because firing early doesn't help. + // + uint64_t deficit = mUnitCost - mCredit; + uint64_t msecWait = (deficit + (kUsecPerMsec - 1)) / kUsecPerMsec; + + if (msecWait < 4) // minimum wait + msecWait = 4; + else if (msecWait > 60000) // maximum wait + msecWait = 60000; + +#ifdef XP_WIN + FineGrainTimers(); +#endif + + SOCKET_LOG( + ("EventTokenBucket::UpdateTimer %p for %" PRIu64 "ms\n", this, msecWait)); + nsresult rv = mTimer->InitWithCallback(this, static_cast<uint32_t>(msecWait), + nsITimer::TYPE_ONE_SHOT); + mTimerArmed = NS_SUCCEEDED(rv); +} + +NS_IMETHODIMP +EventTokenBucket::Notify(nsITimer* timer) { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + +#ifdef XP_WIN + if (timer == mFineGrainResetTimer) { + FineGrainResetTimerNotify(); + return NS_OK; + } +#endif + + SOCKET_LOG(("EventTokenBucket::Notify() %p\n", this)); + mTimerArmed = false; + if (mStopped) return NS_OK; + + UpdateCredits(); + DispatchEvents(); + UpdateTimer(); + + return NS_OK; +} + +NS_IMETHODIMP +EventTokenBucket::GetName(nsACString& aName) { + aName.AssignLiteral("EventTokenBucket"); + return NS_OK; +} + +void EventTokenBucket::UpdateCredits() { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + TimeStamp now = TimeStamp::Now(); + TimeDuration elapsed = now - mLastUpdate; + mLastUpdate = now; + + mCredit += static_cast<uint64_t>(elapsed.ToMicroseconds()); + if (mCredit > mMaxCredit) mCredit = mMaxCredit; + SOCKET_LOG(("EventTokenBucket::UpdateCredits %p to %" PRIu64 " (%" PRIu64 + " each.. %3.2f)\n", + this, mCredit, mUnitCost, (double)mCredit / mUnitCost)); +} + +#ifdef XP_WIN +void EventTokenBucket::FineGrainTimers() { + SOCKET_LOG(("EventTokenBucket::FineGrainTimers %p mFineGrainTimerInUse=%d\n", + this, mFineGrainTimerInUse)); + + mLastFineGrainTimerUse = TimeStamp::Now(); + + if (mFineGrainTimerInUse) return; + + if (mUnitCost > kCostFineGrainThreshold) return; + + SOCKET_LOG( + ("EventTokenBucket::FineGrainTimers %p timeBeginPeriod()\n", this)); + + mFineGrainTimerInUse = true; + timeBeginPeriod(1); +} + +void EventTokenBucket::NormalTimers() { + if (!mFineGrainTimerInUse) return; + mFineGrainTimerInUse = false; + + SOCKET_LOG(("EventTokenBucket::NormalTimers %p timeEndPeriod()\n", this)); + timeEndPeriod(1); +} + +void EventTokenBucket::WantNormalTimers() { + if (!mFineGrainTimerInUse) return; + if (mFineGrainResetTimerArmed) return; + + TimeDuration elapsed(TimeStamp::Now() - mLastFineGrainTimerUse); + static const TimeDuration fiveSeconds = TimeDuration::FromSeconds(5); + + if (elapsed >= fiveSeconds) { + NormalTimers(); + return; + } + + if (!mFineGrainResetTimer) mFineGrainResetTimer = NS_NewTimer(); + + // if we can't delay the reset, just do it now + if (!mFineGrainResetTimer) { + NormalTimers(); + return; + } + + // pad the callback out 100ms to avoid having to round trip this again if the + // timer calls back just a tad early. + SOCKET_LOG( + ("EventTokenBucket::WantNormalTimers %p " + "Will reset timer granularity after delay", + this)); + + mFineGrainResetTimer->InitWithCallback( + this, + static_cast<uint32_t>((fiveSeconds - elapsed).ToMilliseconds()) + 100, + nsITimer::TYPE_ONE_SHOT); + mFineGrainResetTimerArmed = true; +} + +void EventTokenBucket::FineGrainResetTimerNotify() { + SOCKET_LOG(("EventTokenBucket::FineGrainResetTimerNotify() events = %d\n", + this, mEvents.GetSize())); + mFineGrainResetTimerArmed = false; + + // If we are currently processing events then wait for the queue to drain + // before trying to reset back to normal timers again + if (!mEvents.GetSize()) WantNormalTimers(); +} + +#endif + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/EventTokenBucket.h b/netwerk/base/EventTokenBucket.h new file mode 100644 index 0000000000..cab8937400 --- /dev/null +++ b/netwerk/base/EventTokenBucket.h @@ -0,0 +1,155 @@ +/* -*- 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/. */ + +#ifndef NetEventTokenBucket_h__ +#define NetEventTokenBucket_h__ + +#include "ARefBase.h" +#include "nsCOMPtr.h" +#include "nsDeque.h" +#include "nsINamed.h" +#include "nsITimer.h" + +#include "mozilla/TimeStamp.h" + +class nsICancelable; + +namespace mozilla { +namespace net { + +/* A token bucket is used to govern the maximum rate a series of events + can be executed at. For instance if your event was "eat a piece of cake" + then a token bucket configured to allow "1 piece per day" would spread + the eating of a 8 piece cake over 8 days even if you tried to eat the + whole thing up front. In a practical sense it 'costs' 1 token to execute + an event and tokens are 'earned' at a particular rate as time goes by. + + The token bucket can be perfectly smooth or allow a configurable amount of + burstiness. A bursty token bucket allows you to save up unused credits, while + a perfectly smooth one would not. A smooth "1 per day" cake token bucket + would require 9 days to eat that cake if you skipped a slice on day 4 + (use the token or lose it), while a token bucket configured with a burst + of 2 would just let you eat 2 slices on day 5 (the credits for day 4 and day + 5) and finish the cake in the usual 8 days. + + EventTokenBucket(hz=20, burst=5) creates a token bucket with the following + properties: + + + events from an infinite stream will be admitted 20 times per second (i.e. + hz=20 means 1 event per 50 ms). Timers will be used to space things evenly + down to 5ms gaps (i.e. up to 200hz). Token buckets with rates greater than + 200hz will admit multiple events with 5ms gaps between them. 10000hz is the + maximum rate and 1hz is the minimum rate. + + + The burst size controls the limit of 'credits' that a token bucket can + accumulate when idle. For our (20,5) example each event requires 50ms of + credit (again, 20hz = 50ms per event). a burst size of 5 means that the + token bucket can accumulate a maximum of 250ms (5 * 50ms) for this bucket. + If no events have been admitted for the last full second the bucket can + still only accumulate 250ms of credit - but that credit means that 5 events + can be admitted without delay. A burst size of 1 is the minimum. The + EventTokenBucket is created with maximum credits already applied, but they + can be cleared with the ClearCredits() method. The maximum burst size is 15 + minutes worth of events. + + + An event is submitted to the token bucket asynchronously through + SubmitEvent(). The OnTokenBucketAdmitted() method of the submitted event + is used as a callback when the event is ready to run. A cancelable event is + returned to the SubmitEvent() caller for use in the case they do not wish + to wait for the callback. +*/ + +class EventTokenBucket; + +class ATokenBucketEvent { + public: + virtual void OnTokenBucketAdmitted() = 0; +}; + +class TokenBucketCancelable; + +class EventTokenBucket : public nsITimerCallback, + public nsINamed, + public ARefBase { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSITIMERCALLBACK + NS_DECL_NSINAMED + + // This should be constructed on the main thread + EventTokenBucket(uint32_t eventsPerSecond, uint32_t burstSize); + + // These public methods are all meant to be called from the socket thread + void ClearCredits(); + uint32_t BurstEventsAvailable(); + uint32_t QueuedEvents(); + + // a paused token bucket will not process any events, but it will accumulate + // credits. ClearCredits can be used before unpausing if desired. + void Pause(); + void UnPause(); + void Stop(); + + // The returned cancelable event can only be canceled from the socket thread + nsresult SubmitEvent(ATokenBucketEvent* event, nsICancelable** cancelable); + + private: + virtual ~EventTokenBucket(); + void CleanupTimers(); + + friend class RunNotifyEvent; + friend class SetTimerEvent; + + bool TryImmediateDispatch(TokenBucketCancelable* event); + void SetRate(uint32_t eventsPerSecond, uint32_t burstSize); + + void DispatchEvents(); + void UpdateTimer(); + void UpdateCredits(); + + const static uint64_t kUsecPerSec = 1000000; + const static uint64_t kUsecPerMsec = 1000; + const static uint64_t kMaxHz = 10000; + + uint64_t + mUnitCost; // usec of credit needed for 1 event (from eventsPerSecond) + uint64_t mMaxCredit; // usec mCredit limit (from busrtSize) + uint64_t mCredit; // usec of accumulated credit. + + bool mPaused; + bool mStopped; + nsRefPtrDeque<TokenBucketCancelable> mEvents; + bool mTimerArmed; + TimeStamp mLastUpdate; + + // The timer is created on the main thread, but is armed and executes Notify() + // callbacks on the socket thread in order to maintain low latency of event + // delivery. + nsCOMPtr<nsITimer> mTimer; + +#ifdef XP_WIN + // Windows timers are 15ms granularity by default. When we have active events + // that need to be dispatched at 50ms or less granularity we change the OS + // granularity to 1ms. 90 seconds after that need has elapsed we will change + // it back + const static uint64_t kCostFineGrainThreshold = 50 * kUsecPerMsec; + + void FineGrainTimers(); // get 1ms granularity + void NormalTimers(); // reset to default granularity + void WantNormalTimers(); // reset after 90 seconds if not needed in interim + void FineGrainResetTimerNotify(); // delayed callback to reset + + TimeStamp mLastFineGrainTimerUse; + bool mFineGrainTimerInUse; + bool mFineGrainResetTimerArmed; + nsCOMPtr<nsITimer> mFineGrainResetTimer; +#endif +}; + +} // namespace net +} // namespace mozilla + +#endif diff --git a/netwerk/base/FuzzyLayer.cpp b/netwerk/base/FuzzyLayer.cpp new file mode 100644 index 0000000000..6fb92a1917 --- /dev/null +++ b/netwerk/base/FuzzyLayer.cpp @@ -0,0 +1,340 @@ +/* -*- 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 "FuzzyLayer.h" +#include "nsDataHashtable.h" +#include "nsDeque.h" +#include "nsIRunnable.h" +#include "nsSocketTransportService2.h" +#include "nsThreadUtils.h" + +#include "prmem.h" +#include "prio.h" +#include "mozilla/Logging.h" +#include "mozilla/Mutex.h" + +namespace mozilla { +namespace net { + +LazyLogModule gFuzzingLog("nsFuzzingNecko"); + +#define FUZZING_LOG(args) \ + MOZ_LOG(mozilla::net::gFuzzingLog, mozilla::LogLevel::Verbose, args) + +// Mutex for modifying our hash tables +Mutex gConnRecvMutex("ConnectRecvMutex"); + +// This structure will be created by addNetworkFuzzingBuffer below +// and then added to the gNetworkFuzzingBuffers structure. +// +// It is assigned on connect and associated with the socket it belongs to. +typedef struct { + const uint8_t* buf; + size_t size; + bool allowRead; + bool allowUnused; +} NetworkFuzzingBuffer; + +// This holds all connections we have currently open. +static nsDataHashtable<nsPtrHashKey<PRFileDesc>, NetworkFuzzingBuffer*> + gConnectedNetworkFuzzingBuffers; + +// This holds all buffers for connections we can still open. +static nsDeque<NetworkFuzzingBuffer> gNetworkFuzzingBuffers; + +// This is `true` once all connections are closed and either there are +// no buffers left to be used or all remaining buffers are marked optional. +// Used by `signalNetworkFuzzingDone` to tell the main thread if it needs +// to spin-wait for `gFuzzingConnClosed`. +static Atomic<bool> fuzzingNoWaitRequired(false); + +// Used to memorize if the main thread has indicated that it is done with +// its iteration and we don't expect more connections now. +static Atomic<bool> fuzzingMainSignaledDone(false); + +/* + * The flag `gFuzzingConnClosed` is set by `FuzzyClose` when all connections + * are closed *and* there are no more buffers in `gNetworkFuzzingBuffers` that + * must be used. The main thread spins until this becomes true to synchronize + * the fuzzing iteration between the main thread and the socket thread, if + * the prior call to `signalNetworkFuzzingDone` returned `false`. + */ +Atomic<bool> gFuzzingConnClosed(true); + +void addNetworkFuzzingBuffer(const uint8_t* data, size_t size, bool readFirst, + bool useIsOptional) { + if (size > INT32_MAX) { + MOZ_CRASH("Unsupported buffer size"); + } + + MutexAutoLock lock(gConnRecvMutex); + + NetworkFuzzingBuffer* buf = new NetworkFuzzingBuffer(); + buf->buf = data; + buf->size = size; + buf->allowRead = readFirst; + buf->allowUnused = useIsOptional; + + gNetworkFuzzingBuffers.Push(buf); + + fuzzingMainSignaledDone = false; + fuzzingNoWaitRequired = false; +} + +/* + * This method should be called by fuzzing from the main thread to signal to + * the layer code that a fuzzing iteration is done. As a result, we can throw + * away any optional buffers and signal back once all connections have been + * closed. The main thread should synchronize on all connections being closed + * after the actual request/action is complete. + */ +bool signalNetworkFuzzingDone() { + FUZZING_LOG(("[signalNetworkFuzzingDone] Called.")); + MutexAutoLock lock(gConnRecvMutex); + bool rv = false; + + if (fuzzingNoWaitRequired) { + FUZZING_LOG(("[signalNetworkFuzzingDone] Purging remaining buffers.")); + // Easy case, we already have no connections and non-optional buffers left. + gNetworkFuzzingBuffers.Erase(); + gFuzzingConnClosed = true; + rv = true; + } else { + // We still have either connections left open or non-optional buffers left. + // In this case, FuzzyClose will handle the tear-down and signaling. + fuzzingMainSignaledDone = true; + } + + return rv; +} + +static PRDescIdentity sFuzzyLayerIdentity; +static PRIOMethods sFuzzyLayerMethods; +static PRIOMethods* sFuzzyLayerMethodsPtr = nullptr; + +static PRInt16 PR_CALLBACK FuzzyPoll(PRFileDesc* fd, PRInt16 in_flags, + PRInt16* out_flags) { + *out_flags = 0; + + FUZZING_LOG(("[FuzzyPoll] Called with in_flags=%X.", in_flags)); + + NetworkFuzzingBuffer* fuzzBuf = gConnectedNetworkFuzzingBuffers.Get(fd); + + if (in_flags & PR_POLL_READ && fuzzBuf && fuzzBuf->allowRead) { + *out_flags = PR_POLL_READ; + return PR_POLL_READ; + } + + if (in_flags & PR_POLL_WRITE) { + *out_flags = PR_POLL_WRITE; + return PR_POLL_WRITE; + } + + return in_flags; +} + +static PRStatus FuzzyConnect(PRFileDesc* fd, const PRNetAddr* addr, + PRIntervalTime timeout) { + MOZ_RELEASE_ASSERT(fd->identity == sFuzzyLayerIdentity); + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + MutexAutoLock lock(gConnRecvMutex); + + NetworkFuzzingBuffer* buf = gNetworkFuzzingBuffers.PopFront(); + if (!buf) { + FUZZING_LOG(("[FuzzyConnect] Denying additional connection.")); + return PR_FAILURE; + } + + gConnectedNetworkFuzzingBuffers.Put(fd, buf); + fuzzingNoWaitRequired = false; + + FUZZING_LOG(("[FuzzyConnect] Successfully opened connection: %p", fd)); + + gFuzzingConnClosed = false; + + return PR_SUCCESS; +} + +static PRInt32 FuzzySend(PRFileDesc* fd, const void* buf, PRInt32 amount, + PRIntn flags, PRIntervalTime timeout) { + MOZ_RELEASE_ASSERT(fd->identity == sFuzzyLayerIdentity); + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + MutexAutoLock lock(gConnRecvMutex); + + NetworkFuzzingBuffer* fuzzBuf = gConnectedNetworkFuzzingBuffers.Get(fd); + if (!fuzzBuf) { + FUZZING_LOG(("[FuzzySend] Write on socket that is not connected.")); + amount = 0; + } + + // Allow reading once the implementation has written at least some data + if (fuzzBuf && !fuzzBuf->allowRead) { + FUZZING_LOG(("[FuzzySend] Write received, allowing further reads.")); + fuzzBuf->allowRead = true; + } + + FUZZING_LOG(("[FuzzySend] Sent %" PRIx32 " bytes of data.", amount)); + + return amount; +} + +static PRInt32 FuzzyWrite(PRFileDesc* fd, const void* buf, PRInt32 amount) { + return FuzzySend(fd, buf, amount, 0, PR_INTERVAL_NO_WAIT); +} + +static PRInt32 FuzzyRecv(PRFileDesc* fd, void* buf, PRInt32 amount, + PRIntn flags, PRIntervalTime timeout) { + MOZ_RELEASE_ASSERT(fd->identity == sFuzzyLayerIdentity); + + MutexAutoLock lock(gConnRecvMutex); + + NetworkFuzzingBuffer* fuzzBuf = gConnectedNetworkFuzzingBuffers.Get(fd); + if (!fuzzBuf) { + FUZZING_LOG(("[FuzzyRecv] Denying read, connection is closed.")); + return 0; + } + + // As long as we haven't written anything, act as if no data was there yet + if (!fuzzBuf->allowRead) { + FUZZING_LOG(("[FuzzyRecv] Denying read, nothing written before.")); + PR_SetError(PR_WOULD_BLOCK_ERROR, 0); + return -1; + } + + if (gFuzzingConnClosed) { + FUZZING_LOG(("[FuzzyRecv] Denying read, connection is closed.")); + return 0; + } + + // No data left, act as if the connection was closed. + if (!fuzzBuf->size) { + FUZZING_LOG(("[FuzzyRecv] Read failed, no data left.")); + return 0; + } + + // Use the remains of fuzzing buffer, if too little is left + if (fuzzBuf->size < (PRUint32)amount) amount = fuzzBuf->size; + + // Consume buffer, copy data + memcpy(buf, fuzzBuf->buf, amount); + + if (!(flags & PR_MSG_PEEK)) { + fuzzBuf->buf += amount; + fuzzBuf->size -= amount; + } + + FUZZING_LOG(("[FuzzyRecv] Read %" PRIx32 " bytes of data.", amount)); + + return amount; +} + +static PRInt32 FuzzyRead(PRFileDesc* fd, void* buf, PRInt32 amount) { + return FuzzyRecv(fd, buf, amount, 0, PR_INTERVAL_NO_WAIT); +} + +static PRStatus FuzzyClose(PRFileDesc* fd) { + if (!fd) { + return PR_FAILURE; + } + PRFileDesc* layer = PR_PopIOLayer(fd, PR_TOP_IO_LAYER); + MOZ_RELEASE_ASSERT(layer && layer->identity == sFuzzyLayerIdentity, + "Fuzzy Layer not on top of stack"); + + layer->dtor(layer); + + MutexAutoLock lock(gConnRecvMutex); + + NetworkFuzzingBuffer* fuzzBuf = nullptr; + if (gConnectedNetworkFuzzingBuffers.Remove(fd, &fuzzBuf)) { + FUZZING_LOG(("[FuzzyClose] Received close on socket %p", fd)); + delete fuzzBuf; + } else { + /* Happens when close is called on a non-connected socket */ + FUZZING_LOG(("[FuzzyClose] Received close on unknown socket %p.", fd)); + } + + PRStatus ret = fd->methods->close(fd); + + if (!gConnectedNetworkFuzzingBuffers.Count()) { + // At this point, all connections are closed, but we might still have + // unused network buffers that were not marked as optional. + bool haveRemainingUnusedBuffers = false; + for (size_t i = 0; i < gNetworkFuzzingBuffers.GetSize(); ++i) { + NetworkFuzzingBuffer* buf = gNetworkFuzzingBuffers.ObjectAt(i); + + if (!buf->allowUnused) { + haveRemainingUnusedBuffers = true; + break; + } + } + + if (haveRemainingUnusedBuffers) { + FUZZING_LOG( + ("[FuzzyClose] All connections closed, waiting for remaining " + "connections.")); + } else if (!fuzzingMainSignaledDone) { + // We have no connections left, but the main thread hasn't signaled us + // yet. For now, that means once the main thread signals us, we can tell + // it immediately that it won't have to wait for closing connections. + FUZZING_LOG( + ("[FuzzyClose] All connections closed, waiting for main thread.")); + fuzzingNoWaitRequired = true; + } else { + // No connections left and main thread is already done. Perform cleanup + // and then signal the main thread to continue. + FUZZING_LOG(("[FuzzyClose] All connections closed, cleaning up.")); + + gNetworkFuzzingBuffers.Erase(); + gFuzzingConnClosed = true; + + // We need to dispatch this so the main thread is guaranteed to wake up + nsCOMPtr<nsIRunnable> r(new mozilla::Runnable("Dummy")); + NS_DispatchToMainThread(r.forget()); + } + } else { + FUZZING_LOG(("[FuzzyClose] Connection closed.")); + } + + return ret; +} + +nsresult AttachFuzzyIOLayer(PRFileDesc* fd) { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + if (!sFuzzyLayerMethodsPtr) { + sFuzzyLayerIdentity = PR_GetUniqueIdentity("Fuzzy Layer"); + sFuzzyLayerMethods = *PR_GetDefaultIOMethods(); + sFuzzyLayerMethods.connect = FuzzyConnect; + sFuzzyLayerMethods.send = FuzzySend; + sFuzzyLayerMethods.write = FuzzyWrite; + sFuzzyLayerMethods.recv = FuzzyRecv; + sFuzzyLayerMethods.read = FuzzyRead; + sFuzzyLayerMethods.close = FuzzyClose; + sFuzzyLayerMethods.poll = FuzzyPoll; + sFuzzyLayerMethodsPtr = &sFuzzyLayerMethods; + } + + PRFileDesc* layer = + PR_CreateIOLayerStub(sFuzzyLayerIdentity, sFuzzyLayerMethodsPtr); + + if (!layer) { + return NS_ERROR_FAILURE; + } + + PRStatus status = PR_PushIOLayer(fd, PR_TOP_IO_LAYER, layer); + + if (status == PR_FAILURE) { + PR_Free(layer); // PR_CreateIOLayerStub() uses PR_Malloc(). + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/FuzzyLayer.h b/netwerk/base/FuzzyLayer.h new file mode 100644 index 0000000000..6b8109f949 --- /dev/null +++ b/netwerk/base/FuzzyLayer.h @@ -0,0 +1,29 @@ +/* -*- 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/. */ + +#ifndef FuzzyLayer_h__ +#define FuzzyLayer_h__ + +#include "prerror.h" +#include "nsError.h" +#include "nsIFile.h" + +namespace mozilla { +namespace net { + +nsresult AttachFuzzyIOLayer(PRFileDesc* fd); + +extern Atomic<bool> gFuzzingConnClosed; +bool signalNetworkFuzzingDone(); + +void addNetworkFuzzingBuffer(const uint8_t* data, size_t size, + bool readFirst = false, + bool useIsOptional = false); + +} // namespace net +} // namespace mozilla + +#endif // FuzzyLayer_h__ diff --git a/netwerk/base/FuzzySecurityInfo.cpp b/netwerk/base/FuzzySecurityInfo.cpp new file mode 100644 index 0000000000..b2bcf89201 --- /dev/null +++ b/netwerk/base/FuzzySecurityInfo.cpp @@ -0,0 +1,369 @@ +/* -*- 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 "FuzzySecurityInfo.h" +#include "mozilla/Logging.h" +#include "mozilla/OriginAttributes.h" +#include "nsThreadManager.h" + +namespace mozilla { +namespace net { + +FuzzySecurityInfo::FuzzySecurityInfo() {} + +FuzzySecurityInfo::~FuzzySecurityInfo() {} + +NS_IMPL_ISUPPORTS(FuzzySecurityInfo, nsITransportSecurityInfo, + nsIInterfaceRequestor, nsISSLSocketControl) + +NS_IMETHODIMP +FuzzySecurityInfo::GetErrorCode(int32_t* state) { + *state = 0; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetSecurityState(uint32_t* state) { + *state = 0; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetErrorCodeString(nsAString& aErrorString) { + MOZ_CRASH("Unused"); + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetFailedCertChain( + nsTArray<RefPtr<nsIX509Cert>>& aFailedCertChain) { + MOZ_CRASH("Unused"); + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetServerCert(nsIX509Cert** aServerCert) { + NS_ENSURE_ARG_POINTER(aServerCert); + // This method is called by nsHttpChannel::ProcessSSLInformation() + // in order to display certain information in the console. + // Returning NULL is okay here and handled by the caller. + *aServerCert = NULL; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetSucceededCertChain( + nsTArray<RefPtr<nsIX509Cert>>& aSucceededCertChain) { + MOZ_CRASH("Unused"); + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetCipherName(nsACString& aCipherName) { + MOZ_CRASH("Unused"); + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetKeyLength(uint32_t* aKeyLength) { + MOZ_CRASH("Unused"); + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetSecretKeyLength(uint32_t* aSecretKeyLength) { + MOZ_CRASH("Unused"); + *aSecretKeyLength = 4096; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetKeaGroupName(nsACString& aKeaGroup) { + MOZ_CRASH("Unused"); + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetSignatureSchemeName(nsACString& aSignatureScheme) { + MOZ_CRASH("Unused"); + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetProtocolVersion(uint16_t* aProtocolVersion) { + NS_ENSURE_ARG_POINTER(aProtocolVersion); + // Must be >= TLS 1.2 for HTTP2 + *aProtocolVersion = nsITransportSecurityInfo::TLS_VERSION_1_2; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetCertificateTransparencyStatus( + uint16_t* aCertificateTransparencyStatus) { + NS_ENSURE_ARG_POINTER(aCertificateTransparencyStatus); + MOZ_CRASH("Unused"); + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetIsDomainMismatch(bool* aIsDomainMismatch) { + NS_ENSURE_ARG_POINTER(aIsDomainMismatch); + *aIsDomainMismatch = false; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetIsNotValidAtThisTime(bool* aIsNotValidAtThisTime) { + NS_ENSURE_ARG_POINTER(aIsNotValidAtThisTime); + *aIsNotValidAtThisTime = false; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetIsUntrusted(bool* aIsUntrusted) { + NS_ENSURE_ARG_POINTER(aIsUntrusted); + *aIsUntrusted = false; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetIsExtendedValidation(bool* aIsEV) { + NS_ENSURE_ARG_POINTER(aIsEV); + *aIsEV = true; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetIsDelegatedCredential(bool* aIsDelegCred) { + NS_ENSURE_ARG_POINTER(aIsDelegCred); + *aIsDelegCred = false; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetIsAcceptedEch(bool* aIsAcceptedEch) { + NS_ENSURE_ARG_POINTER(aIsAcceptedEch); + *aIsAcceptedEch = false; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetInterface(const nsIID& uuid, void** result) { + if (!NS_IsMainThread()) { + MOZ_CRASH("FuzzySecurityInfo::GetInterface called off the main thread"); + return NS_ERROR_NOT_SAME_THREAD; + } + + nsresult rv = NS_ERROR_NO_INTERFACE; + if (mCallbacks) { + rv = mCallbacks->GetInterface(uuid, result); + } + return rv; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetNotificationCallbacks( + nsIInterfaceRequestor** aCallbacks) { + nsCOMPtr<nsIInterfaceRequestor> ir(mCallbacks); + ir.forget(aCallbacks); + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::SetNotificationCallbacks(nsIInterfaceRequestor* aCallbacks) { + mCallbacks = aCallbacks; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetProviderFlags(uint32_t* aProviderFlags) { + MOZ_CRASH("Unused"); + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetProviderTlsFlags(uint32_t* aProviderTlsFlags) { + MOZ_CRASH("Unused"); + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetKEAUsed(int16_t* aKea) { + // Can be ssl_kea_dh or ssl_kea_ecdh for HTTP2 + *aKea = ssl_kea_ecdh; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetKEAKeyBits(uint32_t* aKeyBits) { + // Must be >= 224 for ecdh and >= 2048 for dh when using HTTP2 + *aKeyBits = 256; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetSSLVersionUsed(int16_t* aSSLVersionUsed) { + // Must be >= TLS 1.2 for HTTP2 + *aSSLVersionUsed = nsISSLSocketControl::TLS_VERSION_1_2; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetSSLVersionOffered(int16_t* aSSLVersionOffered) { + *aSSLVersionOffered = nsISSLSocketControl::TLS_VERSION_1_2; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetMACAlgorithmUsed(int16_t* aMac) { + // The only valid choice for HTTP2 is SSL_MAC_AEAD + *aMac = nsISSLSocketControl::SSL_MAC_AEAD; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetClientCert(nsIX509Cert** aClientCert) { + NS_ENSURE_ARG_POINTER(aClientCert); + *aClientCert = nullptr; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::SetClientCert(nsIX509Cert* aClientCert) { + MOZ_CRASH("Unused"); + return NS_OK; +} + +bool FuzzySecurityInfo::GetDenyClientCert() { return false; } + +void FuzzySecurityInfo::SetDenyClientCert(bool aDenyClientCert) { + // Called by mozilla::net::nsHttpConnection::StartSpdy +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetClientCertSent(bool* arg) { + *arg = false; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetFailedVerification(bool* arg) { + *arg = false; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetNegotiatedNPN(nsACString& aNegotiatedNPN) { + aNegotiatedNPN = "h2"; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetAlpnEarlySelection(nsACString& aAlpnSelected) { + // TODO: For now we don't support early selection + return NS_ERROR_NOT_AVAILABLE; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetEarlyDataAccepted(bool* aAccepted) { + *aAccepted = false; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetResumed(bool* aResumed) { + *aResumed = false; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::DriveHandshake() { return NS_OK; } + +NS_IMETHODIMP +FuzzySecurityInfo::IsAcceptableForHost(const nsACString& hostname, + bool* _retval) { + NS_ENSURE_ARG(_retval); + *_retval = true; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::TestJoinConnection(const nsACString& npnProtocol, + const nsACString& hostname, int32_t port, + bool* _retval) { + *_retval = false; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::JoinConnection(const nsACString& npnProtocol, + const nsACString& hostname, int32_t port, + bool* _retval) { + *_retval = false; + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::ProxyStartSSL() { return NS_OK; } + +NS_IMETHODIMP +FuzzySecurityInfo::StartTLS() { return NS_OK; } + +NS_IMETHODIMP +FuzzySecurityInfo::SetNPNList(nsTArray<nsCString>& protocolArray) { + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetEsniTxt(nsACString& aEsniTxt) { return NS_OK; } + +NS_IMETHODIMP +FuzzySecurityInfo::SetEsniTxt(const nsACString& aEsniTxt) { + MOZ_CRASH("Unused"); + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetEchConfig(nsACString& aEchConfig) { return NS_OK; } + +NS_IMETHODIMP +FuzzySecurityInfo::SetEchConfig(const nsACString& aEchConfig) { + MOZ_CRASH("Unused"); + return NS_OK; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetRetryEchConfig(nsACString& aEchConfig) { return NS_OK; } + +void FuzzySecurityInfo::SerializeToIPC(IPC::Message* aMsg) { + MOZ_CRASH("Unused"); +} + +bool FuzzySecurityInfo::DeserializeFromIPC(const IPC::Message* aMsg, + PickleIterator* aIter) { + MOZ_CRASH("Unused"); + return false; +} + +NS_IMETHODIMP +FuzzySecurityInfo::GetPeerId(nsACString& aResult) { + aResult.Assign(""_ns); + return NS_OK; +} + +NS_IMETHODIMP FuzzySecurityInfo::SetIsBuiltCertChainRootBuiltInRoot( + bool aIsBuiltInRoot) { + return NS_OK; +} + +NS_IMETHODIMP FuzzySecurityInfo::GetIsBuiltCertChainRootBuiltInRoot( + bool* aIsBuiltInRoot) { + *aIsBuiltInRoot = false; + return NS_OK; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/FuzzySecurityInfo.h b/netwerk/base/FuzzySecurityInfo.h new file mode 100644 index 0000000000..eda5260e88 --- /dev/null +++ b/netwerk/base/FuzzySecurityInfo.h @@ -0,0 +1,44 @@ +/* -*- 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/. */ + +#ifndef FuzzySecurityInfo_h__ +#define FuzzySecurityInfo_h__ + +#include "prerror.h" +#include "sslproto.h" +#include "sslt.h" + +#include "nsCOMPtr.h" +#include "nsISSLSocketControl.h" +#include "nsIInterfaceRequestor.h" +#include "nsITransportSecurityInfo.h" + +namespace mozilla { +namespace net { + +class FuzzySecurityInfo final : public nsITransportSecurityInfo, + public nsIInterfaceRequestor, + public nsISSLSocketControl { + public: + FuzzySecurityInfo(); + + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSITRANSPORTSECURITYINFO + NS_DECL_NSIINTERFACEREQUESTOR + NS_DECL_NSISSLSOCKETCONTROL + + protected: + virtual ~FuzzySecurityInfo(); + + private: + nsCOMPtr<nsIInterfaceRequestor> mCallbacks; + +}; // class FuzzySecurityInfo + +} // namespace net +} // namespace mozilla + +#endif // FuzzySecurityInfo_h__ diff --git a/netwerk/base/IOActivityMonitor.cpp b/netwerk/base/IOActivityMonitor.cpp new file mode 100644 index 0000000000..eefc623217 --- /dev/null +++ b/netwerk/base/IOActivityMonitor.cpp @@ -0,0 +1,475 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * 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 "IOActivityMonitor.h" +#include "nsPrintfCString.h" +#include "nsSocketTransport2.h" +#include "nsSocketTransportService2.h" +#include "nsThreadUtils.h" +#include "mozilla/dom/Promise.h" +#include "prerror.h" +#include "prio.h" +#include "prmem.h" +#include <vector> + +using namespace mozilla; +using namespace mozilla::net; + +mozilla::StaticRefPtr<IOActivityMonitor> gInstance; +static PRDescIdentity sNetActivityMonitorLayerIdentity; +static PRIOMethods sNetActivityMonitorLayerMethods; +static PRIOMethods* sNetActivityMonitorLayerMethodsPtr = nullptr; + +// Maximum number of activities entries in the monitoring class +#define MAX_ACTIVITY_ENTRIES 1000 + +// ActivityMonitorSecret is stored in the activity monitor layer +// and provides a method to get the location. +// +// A location can be : +// - a TCP or UDP socket. The form will be socket://ip:port +// - a File. The form will be file://path +// +// For other cases, the location will be fd://number +class ActivityMonitorSecret final { + public: + // constructor used for sockets + explicit ActivityMonitorSecret(PRFileDesc* aFd) { + mFd = aFd; + mLocationSet = false; + } + + // constructor used for files + explicit ActivityMonitorSecret(PRFileDesc* aFd, const char* aLocation) { + mFd = aFd; + mLocation.AppendPrintf("file://%s", aLocation); + mLocationSet = true; + } + + nsCString getLocation() { + if (!mLocationSet) { + LazySetLocation(); + } + return mLocation; + } + + private: + // Called to set the location using the FD on the first getLocation() usage + // which is typically when a socket is opened. If done earlier, at + // construction time, the host won't be bound yet. + // + // If the location is a file, it needs to be initialized in the + // constructor. + void LazySetLocation() { + mLocationSet = true; + PRFileDesc* extract = mFd; + while (PR_GetDescType(extract) == PR_DESC_LAYERED) { + if (!extract->lower) { + break; + } + extract = extract->lower; + } + + PRDescType fdType = PR_GetDescType(extract); + // we should not use LazySetLocation for files + MOZ_ASSERT(fdType != PR_DESC_FILE); + + switch (fdType) { + case PR_DESC_SOCKET_TCP: + case PR_DESC_SOCKET_UDP: { + mLocation.AppendPrintf("socket://"); + PRNetAddr addr; + PRStatus status = PR_GetSockName(mFd, &addr); + if (NS_WARN_IF(status == PR_FAILURE)) { + mLocation.AppendPrintf("unknown"); + break; + } + + // grabbing the host + char netAddr[mozilla::net::kNetAddrMaxCStrBufSize] = {0}; + status = PR_NetAddrToString(&addr, netAddr, sizeof(netAddr) - 1); + if (NS_WARN_IF(status == PR_FAILURE) || netAddr[0] == 0) { + mLocation.AppendPrintf("unknown"); + break; + } + mLocation.Append(netAddr); + + // adding the port + uint16_t port; + if (addr.raw.family == PR_AF_INET) { + port = addr.inet.port; + } else { + port = addr.ipv6.port; + } + mLocation.AppendPrintf(":%d", port); + } break; + + // for all other cases, we just send back fd://<value> + default: { + mLocation.AppendPrintf("fd://%d", PR_FileDesc2NativeHandle(mFd)); + } + } // end switch + } + + private: + nsCString mLocation; + bool mLocationSet; + PRFileDesc* mFd; +}; + +// FileDesc2Location converts a PRFileDesc into a "location" by +// grabbing the ActivityMonitorSecret in layer->secret +static nsAutoCString FileDesc2Location(PRFileDesc* fd) { + nsAutoCString location; + PRFileDesc* monitorLayer = + PR_GetIdentitiesLayer(fd, sNetActivityMonitorLayerIdentity); + if (!monitorLayer) { + location.AppendPrintf("unknown"); + return location; + } + + ActivityMonitorSecret* secret = (ActivityMonitorSecret*)monitorLayer->secret; + location.AppendPrintf("%s", secret->getLocation().get()); + return location; +} + +// +// Wrappers around the socket APIS +// +static PRStatus nsNetMon_Connect(PRFileDesc* fd, const PRNetAddr* addr, + PRIntervalTime timeout) { + return fd->lower->methods->connect(fd->lower, addr, timeout); +} + +static PRStatus nsNetMon_Close(PRFileDesc* fd) { + if (!fd) { + return PR_FAILURE; + } + PRFileDesc* layer = PR_PopIOLayer(fd, PR_TOP_IO_LAYER); + MOZ_RELEASE_ASSERT( + layer && layer->identity == sNetActivityMonitorLayerIdentity, + "NetActivityMonitor Layer not on top of stack"); + + if (layer->secret) { + delete (ActivityMonitorSecret*)layer->secret; + layer->secret = nullptr; + } + layer->dtor(layer); + return fd->methods->close(fd); +} + +static int32_t nsNetMon_Read(PRFileDesc* fd, void* buf, int32_t len) { + int32_t ret = fd->lower->methods->read(fd->lower, buf, len); + if (ret >= 0) { + IOActivityMonitor::Read(fd, len); + } + return ret; +} + +static int32_t nsNetMon_Write(PRFileDesc* fd, const void* buf, int32_t len) { + int32_t ret = fd->lower->methods->write(fd->lower, buf, len); + if (ret > 0) { + IOActivityMonitor::Write(fd, len); + } + return ret; +} + +static int32_t nsNetMon_Writev(PRFileDesc* fd, const PRIOVec* iov, int32_t size, + PRIntervalTime timeout) { + int32_t ret = fd->lower->methods->writev(fd->lower, iov, size, timeout); + if (ret > 0) { + IOActivityMonitor::Write(fd, size); + } + return ret; +} + +static int32_t nsNetMon_Recv(PRFileDesc* fd, void* buf, int32_t amount, + int flags, PRIntervalTime timeout) { + int32_t ret = + fd->lower->methods->recv(fd->lower, buf, amount, flags, timeout); + if (ret > 0) { + IOActivityMonitor::Read(fd, amount); + } + return ret; +} + +static int32_t nsNetMon_Send(PRFileDesc* fd, const void* buf, int32_t amount, + int flags, PRIntervalTime timeout) { + int32_t ret = + fd->lower->methods->send(fd->lower, buf, amount, flags, timeout); + if (ret > 0) { + IOActivityMonitor::Write(fd, amount); + } + return ret; +} + +static int32_t nsNetMon_RecvFrom(PRFileDesc* fd, void* buf, int32_t amount, + int flags, PRNetAddr* addr, + PRIntervalTime timeout) { + int32_t ret = fd->lower->methods->recvfrom(fd->lower, buf, amount, flags, + addr, timeout); + if (ret > 0) { + IOActivityMonitor::Read(fd, amount); + } + return ret; +} + +static int32_t nsNetMon_SendTo(PRFileDesc* fd, const void* buf, int32_t amount, + int flags, const PRNetAddr* addr, + PRIntervalTime timeout) { + int32_t ret = + fd->lower->methods->sendto(fd->lower, buf, amount, flags, addr, timeout); + if (ret > 0) { + IOActivityMonitor::Write(fd, amount); + } + return ret; +} + +static int32_t nsNetMon_AcceptRead(PRFileDesc* listenSock, + PRFileDesc** acceptedSock, + PRNetAddr** peerAddr, void* buf, + int32_t amount, PRIntervalTime timeout) { + int32_t ret = listenSock->lower->methods->acceptread( + listenSock->lower, acceptedSock, peerAddr, buf, amount, timeout); + if (ret > 0) { + IOActivityMonitor::Read(listenSock, amount); + } + return ret; +} + +// +// Class IOActivityMonitor +// +NS_IMPL_ISUPPORTS(IOActivityMonitor, nsINamed) + +IOActivityMonitor::IOActivityMonitor() : mLock("IOActivityMonitor::mLock") { + RefPtr<IOActivityMonitor> mon(gInstance); + MOZ_ASSERT(!mon, "multiple IOActivityMonitor instances!"); +} + +// static +void IOActivityMonitor::RequestActivities(dom::Promise* aPromise) { + MOZ_ASSERT(aPromise); + RefPtr<IOActivityMonitor> mon(gInstance); + if (!IsActive()) { + aPromise->MaybeReject(NS_ERROR_FAILURE); + return; + } + mon->RequestActivitiesInternal(aPromise); +} + +void IOActivityMonitor::RequestActivitiesInternal(dom::Promise* aPromise) { + nsresult result = NS_OK; + FallibleTArray<dom::IOActivityDataDictionary> activities; + + { + mozilla::MutexAutoLock lock(mLock); + // Remove inactive activities + for (auto iter = mActivities.Iter(); !iter.Done(); iter.Next()) { + dom::IOActivityDataDictionary* activity = &iter.Data(); + if (activity->mRx == 0 && activity->mTx == 0) { + iter.Remove(); + } else { + if (NS_WARN_IF(!activities.AppendElement(iter.Data(), fallible))) { + result = NS_ERROR_OUT_OF_MEMORY; + break; + } + } + } + } + + if (NS_WARN_IF(NS_FAILED(result))) { + aPromise->MaybeReject(result); + return; + } + aPromise->MaybeResolve(activities); +} + +// static +NS_IMETHODIMP +IOActivityMonitor::GetName(nsACString& aName) { + aName.AssignLiteral("IOActivityMonitor"); + return NS_OK; +} + +bool IOActivityMonitor::IsActive() { return gInstance != nullptr; } + +nsresult IOActivityMonitor::Init() { + if (IsActive()) { + return NS_ERROR_ALREADY_INITIALIZED; + } + RefPtr<IOActivityMonitor> mon = new IOActivityMonitor(); + nsresult rv = mon->InitInternal(); + if (NS_SUCCEEDED(rv)) { + gInstance = mon; + } + return rv; +} + +nsresult IOActivityMonitor::InitInternal() { + // wraps the socket APIs + if (!sNetActivityMonitorLayerMethodsPtr) { + sNetActivityMonitorLayerIdentity = + PR_GetUniqueIdentity("network activity monitor layer"); + sNetActivityMonitorLayerMethods = *PR_GetDefaultIOMethods(); + sNetActivityMonitorLayerMethods.connect = nsNetMon_Connect; + sNetActivityMonitorLayerMethods.read = nsNetMon_Read; + sNetActivityMonitorLayerMethods.write = nsNetMon_Write; + sNetActivityMonitorLayerMethods.writev = nsNetMon_Writev; + sNetActivityMonitorLayerMethods.recv = nsNetMon_Recv; + sNetActivityMonitorLayerMethods.send = nsNetMon_Send; + sNetActivityMonitorLayerMethods.recvfrom = nsNetMon_RecvFrom; + sNetActivityMonitorLayerMethods.sendto = nsNetMon_SendTo; + sNetActivityMonitorLayerMethods.acceptread = nsNetMon_AcceptRead; + sNetActivityMonitorLayerMethods.close = nsNetMon_Close; + sNetActivityMonitorLayerMethodsPtr = &sNetActivityMonitorLayerMethods; + } + + return NS_OK; +} + +nsresult IOActivityMonitor::Shutdown() { + RefPtr<IOActivityMonitor> mon(gInstance); + if (!mon) { + return NS_ERROR_NOT_INITIALIZED; + } + return mon->ShutdownInternal(); +} + +nsresult IOActivityMonitor::ShutdownInternal() { + mozilla::MutexAutoLock lock(mLock); + mActivities.Clear(); + gInstance = nullptr; + return NS_OK; +} + +nsresult IOActivityMonitor::MonitorSocket(PRFileDesc* aFd) { + RefPtr<IOActivityMonitor> mon(gInstance); + if (!IsActive()) { + return NS_OK; + } + PRFileDesc* layer; + PRStatus status; + layer = PR_CreateIOLayerStub(sNetActivityMonitorLayerIdentity, + sNetActivityMonitorLayerMethodsPtr); + if (!layer) { + return NS_ERROR_FAILURE; + } + + ActivityMonitorSecret* secret = new ActivityMonitorSecret(aFd); + layer->secret = reinterpret_cast<PRFilePrivate*>(secret); + status = PR_PushIOLayer(aFd, PR_NSPR_IO_LAYER, layer); + + if (status == PR_FAILURE) { + delete secret; + PR_Free(layer); // PR_CreateIOLayerStub() uses PR_Malloc(). + return NS_ERROR_FAILURE; + } + return NS_OK; +} + +nsresult IOActivityMonitor::MonitorFile(PRFileDesc* aFd, const char* aPath) { + RefPtr<IOActivityMonitor> mon(gInstance); + if (!IsActive()) { + return NS_OK; + } + PRFileDesc* layer; + PRStatus status; + layer = PR_CreateIOLayerStub(sNetActivityMonitorLayerIdentity, + sNetActivityMonitorLayerMethodsPtr); + if (!layer) { + return NS_ERROR_FAILURE; + } + + ActivityMonitorSecret* secret = new ActivityMonitorSecret(aFd, aPath); + layer->secret = reinterpret_cast<PRFilePrivate*>(secret); + + status = PR_PushIOLayer(aFd, PR_NSPR_IO_LAYER, layer); + if (status == PR_FAILURE) { + delete secret; + PR_Free(layer); // PR_CreateIOLayerStub() uses PR_Malloc(). + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +bool IOActivityMonitor::IncrementActivity(const nsACString& aLocation, + uint32_t aRx, uint32_t aTx) { + mLock.AssertCurrentThreadOwns(); + if (auto entry = mActivities.Lookup(aLocation)) { + // already registered + entry.Data().mTx += aTx; + entry.Data().mRx += aRx; + return true; + } + // Creating a new IOActivity. Notice that mActivities will + // grow indefinitely, which is OK since we won't have + // but a few hundreds entries at the most, but we + // want to assert we have at the most 1000 entries + MOZ_ASSERT(mActivities.Count() < MAX_ACTIVITY_ENTRIES); + + dom::IOActivityDataDictionary activity; + activity.mLocation.Assign(aLocation); + activity.mTx = aTx; + activity.mRx = aRx; + + if (NS_WARN_IF(!mActivities.Put(aLocation, activity, fallible))) { + return false; + } + return true; +} + +nsresult IOActivityMonitor::Write(const nsACString& aLocation, + uint32_t aAmount) { + RefPtr<IOActivityMonitor> mon(gInstance); + if (!mon) { + return NS_ERROR_FAILURE; + } + return mon->WriteInternal(aLocation, aAmount); +} + +nsresult IOActivityMonitor::Write(PRFileDesc* fd, uint32_t aAmount) { + RefPtr<IOActivityMonitor> mon(gInstance); + if (!mon) { + return NS_ERROR_FAILURE; + } + return mon->Write(FileDesc2Location(fd), aAmount); +} + +nsresult IOActivityMonitor::WriteInternal(const nsACString& aLocation, + uint32_t aAmount) { + mozilla::MutexAutoLock lock(mLock); + if (!IncrementActivity(aLocation, aAmount, 0)) { + return NS_ERROR_FAILURE; + } + return NS_OK; +} + +nsresult IOActivityMonitor::Read(PRFileDesc* fd, uint32_t aAmount) { + RefPtr<IOActivityMonitor> mon(gInstance); + if (!mon) { + return NS_ERROR_FAILURE; + } + return mon->Read(FileDesc2Location(fd), aAmount); +} + +nsresult IOActivityMonitor::Read(const nsACString& aLocation, + uint32_t aAmount) { + RefPtr<IOActivityMonitor> mon(gInstance); + if (!mon) { + return NS_ERROR_FAILURE; + } + return mon->ReadInternal(aLocation, aAmount); +} + +nsresult IOActivityMonitor::ReadInternal(const nsACString& aLocation, + uint32_t aAmount) { + mozilla::MutexAutoLock lock(mLock); + if (!IncrementActivity(aLocation, 0, aAmount)) { + return NS_ERROR_FAILURE; + } + return NS_OK; +} diff --git a/netwerk/base/IOActivityMonitor.h b/netwerk/base/IOActivityMonitor.h new file mode 100644 index 0000000000..719ea1f3ab --- /dev/null +++ b/netwerk/base/IOActivityMonitor.h @@ -0,0 +1,79 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * 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/. */ + +#ifndef IOActivityMonitor_h___ +#define IOActivityMonitor_h___ + +#include "mozilla/dom/ChromeUtilsBinding.h" +#include "nsCOMPtr.h" +#include "nscore.h" +#include "nsClassHashtable.h" +#include "nsDataHashtable.h" +#include "nsHashKeys.h" +#include "nsISupports.h" +#include "prinrval.h" +#include "prio.h" +#include "private/pprio.h" +#include <stdint.h> + +namespace mozilla { + +namespace dom { +class Promise; +} + +namespace net { + +#define IO_ACTIVITY_ENABLED_PREF "io.activity.enabled" + +typedef nsDataHashtable<nsCStringHashKey, dom::IOActivityDataDictionary> + Activities; + +// IOActivityMonitor has several roles: +// - maintains an IOActivity per resource and updates it +// - sends a dump of the activities to a promise via RequestActivities +class IOActivityMonitor final : public nsINamed { + public: + IOActivityMonitor(); + + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSINAMED + + // initializes and destroys the singleton + static nsresult Init(); + static nsresult Shutdown(); + + // collect amounts of data that are written/read by location + static nsresult Read(const nsACString& location, uint32_t aAmount); + static nsresult Write(const nsACString& location, uint32_t aAmount); + + static nsresult MonitorFile(PRFileDesc* aFd, const char* aPath); + static nsresult MonitorSocket(PRFileDesc* aFd); + static nsresult Read(PRFileDesc* fd, uint32_t aAmount); + static nsresult Write(PRFileDesc* fd, uint32_t aAmount); + + static bool IsActive(); + static void RequestActivities(dom::Promise* aPromise); + + private: + ~IOActivityMonitor() = default; + nsresult InitInternal(); + nsresult ShutdownInternal(); + bool IncrementActivity(const nsACString& location, uint32_t aRx, + uint32_t aTx); + nsresult WriteInternal(const nsACString& location, uint32_t aAmount); + nsresult ReadInternal(const nsACString& location, uint32_t aAmount); + void RequestActivitiesInternal(dom::Promise* aPromise); + + Activities mActivities; + // protects mActivities accesses + Mutex mLock; +}; + +} // namespace net +} // namespace mozilla + +#endif /* IOActivityMonitor_h___ */ diff --git a/netwerk/base/IPv6Utils.h b/netwerk/base/IPv6Utils.h new file mode 100644 index 0000000000..437c0befec --- /dev/null +++ b/netwerk/base/IPv6Utils.h @@ -0,0 +1,50 @@ +/* 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/. */ + +#ifndef NETWORK_IPV6_UTILS_H_ +#define NETWORK_IPV6_UTILS_H_ + +namespace mozilla { +namespace net { +namespace utils { + +// IPv6 address scopes. +#define IPV6_SCOPE_GLOBAL 0 // Global scope. +#define IPV6_SCOPE_LINKLOCAL 1 // Link-local scope. +#define IPV6_SCOPE_SITELOCAL 2 // Site-local scope (deprecated). +#define IPV6_SCOPE_UNIQUELOCAL 3 // Unique local +#define IPV6_SCOPE_NODELOCAL 4 // Loopback + +// Return the scope of the given address. +static int ipv6_scope(const unsigned char addr[16]) { + const unsigned char* b = addr; + unsigned short w = (unsigned short)((b[0] << 8) | b[1]); + + if ((b[0] & 0xFE) == 0xFC) { + return IPV6_SCOPE_UNIQUELOCAL; + } + switch (w & 0xFFC0) { + case 0xFE80: + return IPV6_SCOPE_LINKLOCAL; + case 0xFEC0: + return IPV6_SCOPE_SITELOCAL; + case 0x0000: + w = b[1] | b[2] | b[3] | b[4] | b[5] | b[6] | b[7] | b[8] | b[9] | b[10] | + b[11] | b[12] | b[13] | b[14]; + if (w || b[15] != 0x01) { + break; + } + return IPV6_SCOPE_NODELOCAL; + default: + break; + } + + return IPV6_SCOPE_GLOBAL; +} + +} // namespace utils +} // namespace net +} // namespace mozilla + +#endif // NETWORK_IPV6_UTILS_H_ diff --git a/netwerk/base/LoadContextInfo.cpp b/netwerk/base/LoadContextInfo.cpp new file mode 100644 index 0000000000..f96246eb40 --- /dev/null +++ b/netwerk/base/LoadContextInfo.cpp @@ -0,0 +1,169 @@ +/* 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 "LoadContextInfo.h" + +#include "mozilla/dom/ToJSValue.h" +#include "mozilla/StoragePrincipalHelper.h" +#include "nsDocShell.h" +#include "nsIChannel.h" +#include "nsILoadContext.h" +#include "nsIWebNavigation.h" +#include "nsNetUtil.h" + +using namespace mozilla::dom; +namespace mozilla { +namespace net { + +// LoadContextInfo + +NS_IMPL_ISUPPORTS(LoadContextInfo, nsILoadContextInfo) + +LoadContextInfo::LoadContextInfo(bool aIsAnonymous, + OriginAttributes aOriginAttributes) + : mIsAnonymous(aIsAnonymous), + mOriginAttributes(std::move(aOriginAttributes)) {} + +NS_IMETHODIMP LoadContextInfo::GetIsPrivate(bool* aIsPrivate) { + *aIsPrivate = mOriginAttributes.mPrivateBrowsingId > 0; + return NS_OK; +} + +NS_IMETHODIMP LoadContextInfo::GetIsAnonymous(bool* aIsAnonymous) { + *aIsAnonymous = mIsAnonymous; + return NS_OK; +} + +OriginAttributes const* LoadContextInfo::OriginAttributesPtr() { + return &mOriginAttributes; +} + +NS_IMETHODIMP LoadContextInfo::GetOriginAttributes( + JSContext* aCx, JS::MutableHandle<JS::Value> aVal) { + if (NS_WARN_IF(!ToJSValue(aCx, mOriginAttributes, aVal))) { + return NS_ERROR_FAILURE; + } + return NS_OK; +} + +// LoadContextInfoFactory + +NS_IMPL_ISUPPORTS(LoadContextInfoFactory, nsILoadContextInfoFactory) + +NS_IMETHODIMP LoadContextInfoFactory::GetDefault( + nsILoadContextInfo** aDefault) { + nsCOMPtr<nsILoadContextInfo> info = + GetLoadContextInfo(false, OriginAttributes()); + info.forget(aDefault); + return NS_OK; +} + +NS_IMETHODIMP LoadContextInfoFactory::GetPrivate( + nsILoadContextInfo** aPrivate) { + OriginAttributes attrs; + attrs.SyncAttributesWithPrivateBrowsing(true); + nsCOMPtr<nsILoadContextInfo> info = GetLoadContextInfo(false, attrs); + info.forget(aPrivate); + return NS_OK; +} + +NS_IMETHODIMP LoadContextInfoFactory::GetAnonymous( + nsILoadContextInfo** aAnonymous) { + nsCOMPtr<nsILoadContextInfo> info = + GetLoadContextInfo(true, OriginAttributes()); + info.forget(aAnonymous); + return NS_OK; +} + +NS_IMETHODIMP LoadContextInfoFactory::Custom(bool aAnonymous, + JS::HandleValue aOriginAttributes, + JSContext* cx, + nsILoadContextInfo** _retval) { + OriginAttributes attrs; + bool status = attrs.Init(cx, aOriginAttributes); + NS_ENSURE_TRUE(status, NS_ERROR_FAILURE); + + nsCOMPtr<nsILoadContextInfo> info = GetLoadContextInfo(aAnonymous, attrs); + info.forget(_retval); + return NS_OK; +} + +NS_IMETHODIMP LoadContextInfoFactory::FromLoadContext( + nsILoadContext* aLoadContext, bool aAnonymous, + nsILoadContextInfo** _retval) { + nsCOMPtr<nsILoadContextInfo> info = + GetLoadContextInfo(aLoadContext, aAnonymous); + info.forget(_retval); + return NS_OK; +} + +NS_IMETHODIMP LoadContextInfoFactory::FromWindow(nsIDOMWindow* aWindow, + bool aAnonymous, + nsILoadContextInfo** _retval) { + nsCOMPtr<nsILoadContextInfo> info = GetLoadContextInfo(aWindow, aAnonymous); + info.forget(_retval); + return NS_OK; +} + +// Helper functions + +LoadContextInfo* GetLoadContextInfo(nsIChannel* aChannel) { + nsresult rv; + + DebugOnly<bool> pb = NS_UsePrivateBrowsing(aChannel); + + bool anon = false; + nsLoadFlags loadFlags; + rv = aChannel->GetLoadFlags(&loadFlags); + if (NS_SUCCEEDED(rv)) { + anon = !!(loadFlags & nsIChannel::LOAD_ANONYMOUS); + } + + OriginAttributes oa; + StoragePrincipalHelper::GetOriginAttributesForNetworkState(aChannel, oa); + MOZ_ASSERT(pb == (oa.mPrivateBrowsingId > 0)); + + return new LoadContextInfo(anon, oa); +} + +LoadContextInfo* GetLoadContextInfo(nsILoadContext* aLoadContext, + bool aIsAnonymous) { + if (!aLoadContext) { + return new LoadContextInfo(aIsAnonymous, OriginAttributes()); + } + + OriginAttributes oa; + aLoadContext->GetOriginAttributes(oa); + +#ifdef DEBUG + nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(aLoadContext); + if (!docShell || + nsDocShell::Cast(docShell)->GetBrowsingContext()->IsContent()) { + MOZ_ASSERT(aLoadContext->UsePrivateBrowsing() == + (oa.mPrivateBrowsingId > 0)); + } +#endif + + return new LoadContextInfo(aIsAnonymous, oa); +} + +LoadContextInfo* GetLoadContextInfo(nsIDOMWindow* aWindow, bool aIsAnonymous) { + nsCOMPtr<nsIWebNavigation> webNav = do_GetInterface(aWindow); + nsCOMPtr<nsILoadContext> loadContext = do_QueryInterface(webNav); + + return GetLoadContextInfo(loadContext, aIsAnonymous); +} + +LoadContextInfo* GetLoadContextInfo(nsILoadContextInfo* aInfo) { + return new LoadContextInfo(aInfo->IsAnonymous(), + *aInfo->OriginAttributesPtr()); +} + +LoadContextInfo* GetLoadContextInfo(bool const aIsAnonymous, + OriginAttributes const& aOriginAttributes) { + return new LoadContextInfo(aIsAnonymous, aOriginAttributes); +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/LoadContextInfo.h b/netwerk/base/LoadContextInfo.h new file mode 100644 index 0000000000..bf6c4ca0ed --- /dev/null +++ b/netwerk/base/LoadContextInfo.h @@ -0,0 +1,55 @@ +/* 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/. */ + +#ifndef nsLoadContextInfo_h__ +#define nsLoadContextInfo_h__ + +#include "nsILoadContextInfo.h" + +class nsIChannel; +class nsILoadContext; + +namespace mozilla { +namespace net { + +class LoadContextInfo final : public nsILoadContextInfo { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSILOADCONTEXTINFO + + LoadContextInfo(bool aIsAnonymous, OriginAttributes aOriginAttributes); + + private: + virtual ~LoadContextInfo() = default; + + protected: + bool mIsAnonymous : 1; + OriginAttributes mOriginAttributes; +}; + +class LoadContextInfoFactory : public nsILoadContextInfoFactory { + virtual ~LoadContextInfoFactory() = default; + + public: + NS_DECL_ISUPPORTS // deliberately not thread-safe + NS_DECL_NSILOADCONTEXTINFOFACTORY +}; + +LoadContextInfo* GetLoadContextInfo(nsIChannel* aChannel); + +LoadContextInfo* GetLoadContextInfo(nsILoadContext* aLoadContext, + bool aIsAnonymous); + +LoadContextInfo* GetLoadContextInfo(nsIDOMWindow* aLoadContext, + bool aIsAnonymous); + +LoadContextInfo* GetLoadContextInfo(nsILoadContextInfo* aInfo); + +LoadContextInfo* GetLoadContextInfo(bool const aIsAnonymous, + OriginAttributes const& aOriginAttributes); + +} // namespace net +} // namespace mozilla + +#endif diff --git a/netwerk/base/LoadInfo.cpp b/netwerk/base/LoadInfo.cpp new file mode 100644 index 0000000000..3c2f4283f8 --- /dev/null +++ b/netwerk/base/LoadInfo.cpp @@ -0,0 +1,1871 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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 "mozilla/LoadInfo.h" + +#include "js/Array.h" // JS::NewArrayObject +#include "mozilla/Assertions.h" +#include "mozilla/ExpandedPrincipal.h" +#include "mozilla/dom/CanonicalBrowsingContext.h" +#include "mozilla/dom/ClientIPCTypes.h" +#include "mozilla/dom/ClientSource.h" +#include "mozilla/dom/Performance.h" +#include "mozilla/dom/PerformanceStorage.h" +#include "mozilla/dom/BrowserChild.h" +#include "mozilla/dom/ToJSValue.h" +#include "mozilla/dom/BrowsingContext.h" +#include "mozilla/dom/WindowGlobalParent.h" +#include "mozilla/net/CookieJarSettings.h" +#include "mozilla/NullPrincipal.h" +#include "mozilla/StaticPrefs_network.h" +#include "mozilla/StaticPrefs_security.h" +#include "mozIThirdPartyUtil.h" +#include "ThirdPartyUtil.h" +#include "nsFrameLoader.h" +#include "nsFrameLoaderOwner.h" +#include "nsIContentSecurityPolicy.h" +#include "nsIDocShell.h" +#include "mozilla/dom/Document.h" +#include "nsIInterfaceRequestorUtils.h" +#include "nsIScriptElement.h" +#include "nsISupportsImpl.h" +#include "nsISupportsUtils.h" +#include "nsIXPConnect.h" +#include "nsDocShell.h" +#include "nsGlobalWindow.h" +#include "nsMixedContentBlocker.h" +#include "nsQueryObject.h" +#include "nsRedirectHistoryEntry.h" +#include "nsSandboxFlags.h" +#include "nsICookieService.h" + +using namespace mozilla::dom; + +namespace mozilla { +namespace net { + +static nsContentPolicyType InternalContentPolicyTypeForFrame( + CanonicalBrowsingContext* aBrowsingContext) { + const auto& maybeEmbedderElementType = + aBrowsingContext->GetEmbedderElementType(); + MOZ_ASSERT(maybeEmbedderElementType.isSome()); + auto embedderElementType = maybeEmbedderElementType.value(); + + // Assign same type as in nsDocShell::DetermineContentType. + // N.B. internal content policy type will never be TYPE_DOCUMENT + return embedderElementType.EqualsLiteral("iframe") + ? nsIContentPolicy::TYPE_INTERNAL_IFRAME + : nsIContentPolicy::TYPE_INTERNAL_FRAME; +} + +/* static */ already_AddRefed<LoadInfo> LoadInfo::CreateForDocument( + dom::CanonicalBrowsingContext* aBrowsingContext, + nsIPrincipal* aTriggeringPrincipal, + const OriginAttributes& aOriginAttributes, nsSecurityFlags aSecurityFlags, + uint32_t aSandboxFlags) { + return MakeAndAddRef<LoadInfo>(aBrowsingContext, aTriggeringPrincipal, + aOriginAttributes, aSecurityFlags, + aSandboxFlags); +} + +/* static */ already_AddRefed<LoadInfo> LoadInfo::CreateForFrame( + dom::CanonicalBrowsingContext* aBrowsingContext, + nsIPrincipal* aTriggeringPrincipal, nsSecurityFlags aSecurityFlags, + uint32_t aSandboxFlags) { + return MakeAndAddRef<LoadInfo>(aBrowsingContext, aTriggeringPrincipal, + aSecurityFlags, aSandboxFlags); +} + +/* static */ already_AddRefed<LoadInfo> LoadInfo::CreateForNonDocument( + dom::WindowGlobalParent* aParentWGP, nsIPrincipal* aTriggeringPrincipal, + nsContentPolicyType aContentPolicyType, nsSecurityFlags aSecurityFlags, + uint32_t aSandboxFlags) { + return MakeAndAddRef<LoadInfo>(aParentWGP, aTriggeringPrincipal, + aContentPolicyType, aSecurityFlags, + aSandboxFlags); +} + +LoadInfo::LoadInfo( + nsIPrincipal* aLoadingPrincipal, nsIPrincipal* aTriggeringPrincipal, + nsINode* aLoadingContext, nsSecurityFlags aSecurityFlags, + nsContentPolicyType aContentPolicyType, + const Maybe<mozilla::dom::ClientInfo>& aLoadingClientInfo, + const Maybe<mozilla::dom::ServiceWorkerDescriptor>& aController, + uint32_t aSandboxFlags) + : mLoadingPrincipal(aLoadingContext ? aLoadingContext->NodePrincipal() + : aLoadingPrincipal), + mTriggeringPrincipal(aTriggeringPrincipal ? aTriggeringPrincipal + : mLoadingPrincipal.get()), + mClientInfo(aLoadingClientInfo), + mController(aController), + mLoadingContext(do_GetWeakReference(aLoadingContext)), + mSecurityFlags(aSecurityFlags), + mSandboxFlags(aSandboxFlags), + mTriggeringSandboxFlags(0), + mInternalContentPolicyType(aContentPolicyType) { + MOZ_ASSERT(mLoadingPrincipal); + MOZ_ASSERT(mTriggeringPrincipal); + +#ifdef DEBUG + // TYPE_DOCUMENT loads initiated by javascript tests will go through + // nsIOService and use the wrong constructor. Don't enforce the + // !TYPE_DOCUMENT check in those cases + bool skipContentTypeCheck = false; + skipContentTypeCheck = + Preferences::GetBool("network.loadinfo.skip_type_assertion"); +#endif + + // This constructor shouldn't be used for TYPE_DOCUMENT loads that don't + // have a loadingPrincipal + MOZ_ASSERT(skipContentTypeCheck || mLoadingPrincipal || + mInternalContentPolicyType != nsIContentPolicy::TYPE_DOCUMENT); + + // We should only get an explicit controller for subresource requests. + MOZ_DIAGNOSTIC_ASSERT(aController.isNothing() || + !nsContentUtils::IsNonSubresourceInternalPolicyType( + mInternalContentPolicyType)); + + // TODO(bug 1259873): Above, we initialize mIsThirdPartyContext to false + // meaning that consumers of LoadInfo that don't pass a context or pass a + // context from which we can't find a window will default to assuming that + // they're 1st party. It would be nice if we could default "safe" and assume + // that we are 3rd party until proven otherwise. + + // if consumers pass both, aLoadingContext and aLoadingPrincipal + // then the loadingPrincipal must be the same as the node's principal + MOZ_ASSERT(!aLoadingContext || !aLoadingPrincipal || + aLoadingContext->NodePrincipal() == aLoadingPrincipal); + + // if the load is sandboxed, we can not also inherit the principal + if (mSandboxFlags & SANDBOXED_ORIGIN) { + mForceInheritPrincipalDropped = + (mSecurityFlags & nsILoadInfo::SEC_FORCE_INHERIT_PRINCIPAL); + mSecurityFlags &= ~nsILoadInfo::SEC_FORCE_INHERIT_PRINCIPAL; + } + + ExtContentPolicyType externalType = + nsContentUtils::InternalContentPolicyTypeToExternal(aContentPolicyType); + + if (aLoadingContext) { + // Ensure that all network requests for a window client have the ClientInfo + // properly set. Workers must currently pass the loading ClientInfo + // explicitly. We allow main thread requests to explicitly pass the value as + // well. + if (mClientInfo.isNothing()) { + mClientInfo = aLoadingContext->OwnerDoc()->GetClientInfo(); + } + + // For subresource loads set the service worker based on the calling + // context's controller. Workers must currently pass the controller in + // explicitly. We allow main thread requests to explicitly pass the value + // as well, but otherwise extract from the loading context here. + if (mController.isNothing() && + !nsContentUtils::IsNonSubresourceInternalPolicyType( + mInternalContentPolicyType)) { + mController = aLoadingContext->OwnerDoc()->GetController(); + } + + nsCOMPtr<nsPIDOMWindowOuter> contextOuter = + aLoadingContext->OwnerDoc()->GetWindow(); + if (contextOuter) { + ComputeIsThirdPartyContext(contextOuter); + RefPtr<dom::BrowsingContext> bc = contextOuter->GetBrowsingContext(); + MOZ_ASSERT(bc); + mBrowsingContextID = bc->Id(); + + nsGlobalWindowInner* innerWindow = + nsGlobalWindowInner::Cast(contextOuter->GetCurrentInnerWindow()); + if (innerWindow) { + mTopLevelPrincipal = innerWindow->GetTopLevelAntiTrackingPrincipal(); + + // The top-level-storage-area-principal is not null only for the first + // level of iframes (null for top-level contexts, and null for + // sub-iframes). If we are loading a sub-document resource, we must + // calculate what the top-level-storage-area-principal will be for the + // new context. + if (externalType != ExtContentPolicy::TYPE_SUBDOCUMENT) { + mTopLevelStorageAreaPrincipal = + innerWindow->GetTopLevelStorageAreaPrincipal(); + } else if (bc->IsTop()) { + Document* doc = innerWindow->GetExtantDoc(); + if (!doc || (!doc->StorageAccessSandboxed())) { + mTopLevelStorageAreaPrincipal = innerWindow->GetPrincipal(); + } + + // If this is the first level iframe, innerWindow is our top-level + // principal. + if (!mTopLevelPrincipal) { + mTopLevelPrincipal = innerWindow->GetPrincipal(); + } + } + } + + // Let's inherit the cookie behavior and permission from the parent + // document. + mCookieJarSettings = aLoadingContext->OwnerDoc()->CookieJarSettings(); + } + + mInnerWindowID = aLoadingContext->OwnerDoc()->InnerWindowID(); + RefPtr<WindowContext> ctx = WindowContext::GetById(mInnerWindowID); + if (ctx) { + mLoadingEmbedderPolicy = ctx->GetEmbedderPolicy(); + } + mDocumentHasUserInteracted = + aLoadingContext->OwnerDoc()->UserHasInteracted(); + + // Inherit HTTPS-Only Mode flags from parent document + mHttpsOnlyStatus |= aLoadingContext->OwnerDoc()->HttpsOnlyStatus(); + + // When the element being loaded is a frame, we choose the frame's window + // for the window ID and the frame element's window as the parent + // window. This is the behavior that Chrome exposes to add-ons. + // NB: If the frameLoaderOwner doesn't have a frame loader, then the load + // must be coming from an object (such as a plugin) that's loaded into it + // instead of a document being loaded. In that case, treat this object like + // any other non-document-loading element. + RefPtr<nsFrameLoaderOwner> frameLoaderOwner = + do_QueryObject(aLoadingContext); + RefPtr<nsFrameLoader> fl = + frameLoaderOwner ? frameLoaderOwner->GetFrameLoader() : nullptr; + if (fl) { + nsCOMPtr<nsIDocShell> docShell = fl->GetDocShell(IgnoreErrors()); + if (docShell) { + nsCOMPtr<nsPIDOMWindowOuter> outerWindow = do_GetInterface(docShell); + if (outerWindow) { + RefPtr<dom::BrowsingContext> bc = outerWindow->GetBrowsingContext(); + mFrameBrowsingContextID = bc ? bc->Id() : 0; + } + } + } + + // if the document forces all mixed content to be blocked, then we + // store that bit for all requests on the loadinfo. + mBlockAllMixedContent = + aLoadingContext->OwnerDoc()->GetBlockAllMixedContent(false) || + (nsContentUtils::IsPreloadType(mInternalContentPolicyType) && + aLoadingContext->OwnerDoc()->GetBlockAllMixedContent(true)); + + // if the document forces all requests to be upgraded from http to https, + // then we should do that for all requests. If it only forces preloads to be + // upgraded then we should enforce upgrade insecure requests only for + // preloads. + mUpgradeInsecureRequests = + aLoadingContext->OwnerDoc()->GetUpgradeInsecureRequests(false) || + (nsContentUtils::IsPreloadType(mInternalContentPolicyType) && + aLoadingContext->OwnerDoc()->GetUpgradeInsecureRequests(true)); + + if (nsContentUtils::IsUpgradableDisplayType(externalType)) { + if (mLoadingPrincipal->SchemeIs("https")) { + if (StaticPrefs::security_mixed_content_upgrade_display_content()) { + mBrowserUpgradeInsecureRequests = true; + } else { + mBrowserWouldUpgradeInsecureRequests = true; + } + } + } + } + mOriginAttributes = mLoadingPrincipal->OriginAttributesRef(); + + // We need to do this after inheriting the document's origin attributes + // above, in case the loading principal ends up being the system principal. + if (aLoadingContext) { + nsCOMPtr<nsILoadContext> loadContext = + aLoadingContext->OwnerDoc()->GetLoadContext(); + nsCOMPtr<nsIDocShell> docShell = aLoadingContext->OwnerDoc()->GetDocShell(); + if (loadContext && docShell && + docShell->GetBrowsingContext()->IsContent()) { + bool usePrivateBrowsing; + nsresult rv = loadContext->GetUsePrivateBrowsing(&usePrivateBrowsing); + if (NS_SUCCEEDED(rv)) { + mOriginAttributes.SyncAttributesWithPrivateBrowsing(usePrivateBrowsing); + } + } + } + + // For chrome docshell, the mPrivateBrowsingId remains 0 even its + // UsePrivateBrowsing() is true, so we only update the mPrivateBrowsingId in + // origin attributes if the type of the docshell is content. + if (aLoadingContext) { + nsCOMPtr<nsIDocShell> docShell = aLoadingContext->OwnerDoc()->GetDocShell(); + if (docShell) { + if (docShell->GetBrowsingContext()->IsChrome()) { + MOZ_ASSERT(mOriginAttributes.mPrivateBrowsingId == 0, + "chrome docshell shouldn't have mPrivateBrowsingId set."); + } + } + } + + // in case this is a loadinfo for a parser generated script, then we store + // that bit of information so CSP strict-dynamic can query it. + if (!nsContentUtils::IsPreloadType(mInternalContentPolicyType)) { + nsCOMPtr<nsIScriptElement> script = do_QueryInterface(aLoadingContext); + if (script && script->GetParserCreated() != mozilla::dom::NOT_FROM_PARSER) { + mParserCreatedScript = true; + } + } +} + +/* Constructor takes an outer window, but no loadingNode or loadingPrincipal. + * This constructor should only be used for TYPE_DOCUMENT loads, since they + * have a null loadingNode and loadingPrincipal. + */ +LoadInfo::LoadInfo(nsPIDOMWindowOuter* aOuterWindow, + nsIPrincipal* aTriggeringPrincipal, + nsISupports* aContextForTopLevelLoad, + nsSecurityFlags aSecurityFlags, uint32_t aSandboxFlags) + : mTriggeringPrincipal(aTriggeringPrincipal), + mContextForTopLevelLoad(do_GetWeakReference(aContextForTopLevelLoad)), + mSecurityFlags(aSecurityFlags), + mSandboxFlags(aSandboxFlags), + mTriggeringSandboxFlags(0), + mInternalContentPolicyType(nsIContentPolicy::TYPE_DOCUMENT) { + // Top-level loads are never third-party + // Grab the information we can out of the window. + MOZ_ASSERT(aOuterWindow); + MOZ_ASSERT(mTriggeringPrincipal); + + // if the load is sandboxed, we can not also inherit the principal + if (mSandboxFlags & SANDBOXED_ORIGIN) { + mForceInheritPrincipalDropped = + (mSecurityFlags & nsILoadInfo::SEC_FORCE_INHERIT_PRINCIPAL); + mSecurityFlags &= ~nsILoadInfo::SEC_FORCE_INHERIT_PRINCIPAL; + } + + RefPtr<BrowsingContext> bc = aOuterWindow->GetBrowsingContext(); + mBrowsingContextID = bc ? bc->Id() : 0; + + // This should be removed in bug 1618557 + nsGlobalWindowInner* innerWindow = + nsGlobalWindowInner::Cast(aOuterWindow->GetCurrentInnerWindow()); + if (innerWindow) { + mTopLevelPrincipal = innerWindow->GetTopLevelAntiTrackingPrincipal(); + // mTopLevelStorageAreaPrincipal is always null for top-level document + // loading. + } + + // get the docshell from the outerwindow, and then get the originattributes + nsCOMPtr<nsIDocShell> docShell = aOuterWindow->GetDocShell(); + MOZ_ASSERT(docShell); + mOriginAttributes = nsDocShell::Cast(docShell)->GetOriginAttributes(); + + // We sometimes use this constructor for security checks for outer windows + // that aren't top level. + if (aSecurityFlags != nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK) { + MOZ_ASSERT(aOuterWindow->GetBrowsingContext()->IsTop()); + } + +#ifdef DEBUG + if (docShell->GetBrowsingContext()->IsChrome()) { + MOZ_ASSERT(mOriginAttributes.mPrivateBrowsingId == 0, + "chrome docshell shouldn't have mPrivateBrowsingId set."); + } +#endif + + // Let's take the current cookie behavior and current cookie permission + // for the documents' loadInfo. Note that for any other loadInfos, + // cookieBehavior will be BEHAVIOR_REJECT for security reasons. + mCookieJarSettings = CookieJarSettings::Create(); +} + +LoadInfo::LoadInfo(dom::CanonicalBrowsingContext* aBrowsingContext, + nsIPrincipal* aTriggeringPrincipal, + const OriginAttributes& aOriginAttributes, + nsSecurityFlags aSecurityFlags, uint32_t aSandboxFlags) + : mTriggeringPrincipal(aTriggeringPrincipal), + mSecurityFlags(aSecurityFlags), + mSandboxFlags(aSandboxFlags), + mTriggeringSandboxFlags(0), + mInternalContentPolicyType(nsIContentPolicy::TYPE_DOCUMENT) { + // Top-level loads are never third-party + // Grab the information we can out of the window. + MOZ_ASSERT(aBrowsingContext); + MOZ_ASSERT(mTriggeringPrincipal); + MOZ_ASSERT(aSecurityFlags != + nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK); + + // if the load is sandboxed, we can not also inherit the principal + if (mSandboxFlags & SANDBOXED_ORIGIN) { + mForceInheritPrincipalDropped = + (mSecurityFlags & nsILoadInfo::SEC_FORCE_INHERIT_PRINCIPAL); + mSecurityFlags &= ~nsILoadInfo::SEC_FORCE_INHERIT_PRINCIPAL; + } + + mBrowsingContextID = aBrowsingContext->Id(); + mOriginAttributes = aOriginAttributes; + +#ifdef DEBUG + if (aBrowsingContext->IsChrome()) { + MOZ_ASSERT(mOriginAttributes.mPrivateBrowsingId == 0, + "chrome docshell shouldn't have mPrivateBrowsingId set."); + } +#endif + + // Let's take the current cookie behavior and current cookie permission + // for the documents' loadInfo. Note that for any other loadInfos, + // cookieBehavior will be BEHAVIOR_REJECT for security reasons. + mCookieJarSettings = CookieJarSettings::Create(); +} + +LoadInfo::LoadInfo(dom::WindowGlobalParent* aParentWGP, + nsIPrincipal* aTriggeringPrincipal, + nsContentPolicyType aContentPolicyType, + nsSecurityFlags aSecurityFlags, uint32_t aSandboxFlags) + : mTriggeringPrincipal(aTriggeringPrincipal), + mSecurityFlags(aSecurityFlags), + mSandboxFlags(aSandboxFlags), + mInternalContentPolicyType(aContentPolicyType) { + CanonicalBrowsingContext* parentBC = aParentWGP->BrowsingContext(); + MOZ_ASSERT(parentBC); + ComputeAncestors(parentBC, mAncestorPrincipals, mAncestorBrowsingContextIDs); + + RefPtr<WindowGlobalParent> topLevelWGP = aParentWGP->TopWindowContext(); + + // if the load is sandboxed, we can not also inherit the principal + if (mSandboxFlags & SANDBOXED_ORIGIN) { + mForceInheritPrincipalDropped = + (mSecurityFlags & nsILoadInfo::SEC_FORCE_INHERIT_PRINCIPAL); + mSecurityFlags &= ~nsILoadInfo::SEC_FORCE_INHERIT_PRINCIPAL; + } + + // Ensure that all network requests for a window client have the ClientInfo + // properly set. + mClientInfo = aParentWGP->GetClientInfo(); + mLoadingPrincipal = aParentWGP->DocumentPrincipal(); + ComputeIsThirdPartyContext(aParentWGP); + + mBrowsingContextID = parentBC->Id(); + + // Let's inherit the cookie behavior and permission from the embedder + // document. + mCookieJarSettings = aParentWGP->CookieJarSettings(); + if (topLevelWGP->BrowsingContext()->IsTop()) { + if (mCookieJarSettings) { + bool stopAtOurLevel = mCookieJarSettings->GetCookieBehavior() == + nsICookieService::BEHAVIOR_REJECT_TRACKER; + if (!stopAtOurLevel || + topLevelWGP->OuterWindowId() != aParentWGP->OuterWindowId()) { + mTopLevelPrincipal = topLevelWGP->DocumentPrincipal(); + } + } + } + + // The top-level-storage-area-principal is not null only for the first + // level of iframes (null for top-level contexts, and null for + // sub-iframes). If we are loading a sub-document resource, we must + // calculate what the top-level-storage-area-principal will be for the + // new context. + if (parentBC->IsTop()) { + if (!Document::StorageAccessSandboxed(aParentWGP->SandboxFlags())) { + mTopLevelStorageAreaPrincipal = aParentWGP->DocumentPrincipal(); + } + + // If this is the first level iframe, embedder WindowGlobalParent's document + // principal is our top-level principal. + if (!mTopLevelPrincipal) { + mTopLevelPrincipal = aParentWGP->DocumentPrincipal(); + } + } + + mInnerWindowID = aParentWGP->InnerWindowId(); + mDocumentHasUserInteracted = aParentWGP->DocumentHasUserInteracted(); + + // if the document forces all mixed content to be blocked, then we + // store that bit for all requests on the loadinfo. + mBlockAllMixedContent = aParentWGP->GetDocumentBlockAllMixedContent(); + + // if the document forces all requests to be upgraded from http to https, + // then we should do that for all requests. If it only forces preloads to be + // upgraded then we should enforce upgrade insecure requests only for + // preloads. + mUpgradeInsecureRequests = aParentWGP->GetDocumentUpgradeInsecureRequests(); + mOriginAttributes = mLoadingPrincipal->OriginAttributesRef(); + + // We need to do this after inheriting the document's origin attributes + // above, in case the loading principal ends up being the system principal. + if (parentBC->IsContent()) { + mOriginAttributes.SyncAttributesWithPrivateBrowsing( + parentBC->UsePrivateBrowsing()); + } + + mHttpsOnlyStatus |= aParentWGP->HttpsOnlyStatus(); + + // For chrome BC, the mPrivateBrowsingId remains 0 even its + // UsePrivateBrowsing() is true, so we only update the mPrivateBrowsingId in + // origin attributes if the type of the BC is content. + if (parentBC->IsChrome()) { + MOZ_ASSERT(mOriginAttributes.mPrivateBrowsingId == 0, + "chrome docshell shouldn't have mPrivateBrowsingId set."); + } + + RefPtr<WindowContext> ctx = WindowContext::GetById(mInnerWindowID); + if (ctx) { + mLoadingEmbedderPolicy = ctx->GetEmbedderPolicy(); + } +} + +// Used for TYPE_FRAME or TYPE_IFRAME load. +LoadInfo::LoadInfo(dom::CanonicalBrowsingContext* aBrowsingContext, + nsIPrincipal* aTriggeringPrincipal, + nsSecurityFlags aSecurityFlags, uint32_t aSandboxFlags) + : LoadInfo(aBrowsingContext->GetParentWindowContext(), aTriggeringPrincipal, + InternalContentPolicyTypeForFrame(aBrowsingContext), + aSecurityFlags, aSandboxFlags) { + mFrameBrowsingContextID = aBrowsingContext->Id(); +} + +LoadInfo::LoadInfo(const LoadInfo& rhs) + : mLoadingPrincipal(rhs.mLoadingPrincipal), + mTriggeringPrincipal(rhs.mTriggeringPrincipal), + mPrincipalToInherit(rhs.mPrincipalToInherit), + mSandboxedLoadingPrincipal(rhs.mSandboxedLoadingPrincipal), + mTopLevelPrincipal(rhs.mTopLevelPrincipal), + mTopLevelStorageAreaPrincipal(rhs.mTopLevelStorageAreaPrincipal), + mResultPrincipalURI(rhs.mResultPrincipalURI), + mCookieJarSettings(rhs.mCookieJarSettings), + mCspToInherit(rhs.mCspToInherit), + mClientInfo(rhs.mClientInfo), + // mReservedClientSource must be handled specially during redirect + // mReservedClientInfo must be handled specially during redirect + // mInitialClientInfo must be handled specially during redirect + mController(rhs.mController), + mPerformanceStorage(rhs.mPerformanceStorage), + mLoadingContext(rhs.mLoadingContext), + mContextForTopLevelLoad(rhs.mContextForTopLevelLoad), + mSecurityFlags(rhs.mSecurityFlags), + mSandboxFlags(rhs.mSandboxFlags), + mTriggeringSandboxFlags(rhs.mTriggeringSandboxFlags), + mInternalContentPolicyType(rhs.mInternalContentPolicyType), + mTainting(rhs.mTainting), + mBlockAllMixedContent(rhs.mBlockAllMixedContent), + mUpgradeInsecureRequests(rhs.mUpgradeInsecureRequests), + mBrowserUpgradeInsecureRequests(rhs.mBrowserUpgradeInsecureRequests), + mBrowserDidUpgradeInsecureRequests( + rhs.mBrowserDidUpgradeInsecureRequests), + mBrowserWouldUpgradeInsecureRequests( + rhs.mBrowserWouldUpgradeInsecureRequests), + mForceAllowDataURI(rhs.mForceAllowDataURI), + mAllowInsecureRedirectToDataURI(rhs.mAllowInsecureRedirectToDataURI), + mBypassCORSChecks(rhs.mBypassCORSChecks), + mSkipContentPolicyCheckForWebRequest( + rhs.mSkipContentPolicyCheckForWebRequest), + mOriginalFrameSrcLoad(rhs.mOriginalFrameSrcLoad), + mForceInheritPrincipalDropped(rhs.mForceInheritPrincipalDropped), + mInnerWindowID(rhs.mInnerWindowID), + mBrowsingContextID(rhs.mBrowsingContextID), + mFrameBrowsingContextID(rhs.mFrameBrowsingContextID), + mInitialSecurityCheckDone(rhs.mInitialSecurityCheckDone), + mIsThirdPartyContext(rhs.mIsThirdPartyContext), + mIsThirdPartyContextToTopWindow(rhs.mIsThirdPartyContextToTopWindow), + mIsFormSubmission(rhs.mIsFormSubmission), + mSendCSPViolationEvents(rhs.mSendCSPViolationEvents), + mOriginAttributes(rhs.mOriginAttributes), + mRedirectChainIncludingInternalRedirects( + rhs.mRedirectChainIncludingInternalRedirects.Clone()), + mRedirectChain(rhs.mRedirectChain.Clone()), + mAncestorPrincipals(rhs.mAncestorPrincipals.Clone()), + mAncestorBrowsingContextIDs(rhs.mAncestorBrowsingContextIDs.Clone()), + mCorsUnsafeHeaders(rhs.mCorsUnsafeHeaders.Clone()), + mRequestBlockingReason(rhs.mRequestBlockingReason), + mForcePreflight(rhs.mForcePreflight), + mIsPreflight(rhs.mIsPreflight), + mLoadTriggeredFromExternal(rhs.mLoadTriggeredFromExternal), + // mServiceWorkerTaintingSynthesized must be handled specially during + // redirect + mServiceWorkerTaintingSynthesized(false), + mDocumentHasUserInteracted(rhs.mDocumentHasUserInteracted), + mAllowListFutureDocumentsCreatedFromThisRedirectChain( + rhs.mAllowListFutureDocumentsCreatedFromThisRedirectChain), + mCspNonce(rhs.mCspNonce), + mSkipContentSniffing(rhs.mSkipContentSniffing), + mHttpsOnlyStatus(rhs.mHttpsOnlyStatus), + mHasValidUserGestureActivation(rhs.mHasValidUserGestureActivation), + mAllowDeprecatedSystemRequests(rhs.mAllowDeprecatedSystemRequests), + mIsInDevToolsContext(rhs.mIsInDevToolsContext), + mParserCreatedScript(rhs.mParserCreatedScript), + mHasStoragePermission(rhs.mHasStoragePermission), + mIsFromProcessingFrameAttributes(rhs.mIsFromProcessingFrameAttributes), + mLoadingEmbedderPolicy(rhs.mLoadingEmbedderPolicy) {} + +LoadInfo::LoadInfo( + nsIPrincipal* aLoadingPrincipal, nsIPrincipal* aTriggeringPrincipal, + nsIPrincipal* aPrincipalToInherit, nsIPrincipal* aSandboxedLoadingPrincipal, + nsIPrincipal* aTopLevelPrincipal, + nsIPrincipal* aTopLevelStorageAreaPrincipal, nsIURI* aResultPrincipalURI, + nsICookieJarSettings* aCookieJarSettings, + nsIContentSecurityPolicy* aCspToInherit, + const Maybe<ClientInfo>& aClientInfo, + const Maybe<ClientInfo>& aReservedClientInfo, + const Maybe<ClientInfo>& aInitialClientInfo, + const Maybe<ServiceWorkerDescriptor>& aController, + nsSecurityFlags aSecurityFlags, uint32_t aSandboxFlags, + uint32_t aTriggeringSandboxFlags, nsContentPolicyType aContentPolicyType, + LoadTainting aTainting, bool aBlockAllMixedContent, + bool aUpgradeInsecureRequests, bool aBrowserUpgradeInsecureRequests, + bool aBrowserDidUpgradeInsecureRequests, + bool aBrowserWouldUpgradeInsecureRequests, bool aForceAllowDataURI, + bool aAllowInsecureRedirectToDataURI, bool aBypassCORSChecks, + bool aSkipContentPolicyCheckForWebRequest, bool aOriginalFrameSrcLoad, + bool aForceInheritPrincipalDropped, uint64_t aInnerWindowID, + uint64_t aBrowsingContextID, uint64_t aFrameBrowsingContextID, + bool aInitialSecurityCheckDone, bool aIsThirdPartyContext, + bool aIsThirdPartyContextToTopWindow, bool aIsFormSubmission, + bool aSendCSPViolationEvents, const OriginAttributes& aOriginAttributes, + RedirectHistoryArray&& aRedirectChainIncludingInternalRedirects, + RedirectHistoryArray&& aRedirectChain, + nsTArray<nsCOMPtr<nsIPrincipal>>&& aAncestorPrincipals, + const nsTArray<uint64_t>& aAncestorBrowsingContextIDs, + const nsTArray<nsCString>& aCorsUnsafeHeaders, bool aForcePreflight, + bool aIsPreflight, bool aLoadTriggeredFromExternal, + bool aServiceWorkerTaintingSynthesized, bool aDocumentHasUserInteracted, + bool aAllowListFutureDocumentsCreatedFromThisRedirectChain, + const nsAString& aCspNonce, bool aSkipContentSniffing, + uint32_t aHttpsOnlyStatus, bool aHasValidUserGestureActivation, + bool aAllowDeprecatedSystemRequests, bool aIsInDevToolsContext, + bool aParserCreatedScript, bool aHasStoragePermission, + uint32_t aRequestBlockingReason, nsINode* aLoadingContext, + nsILoadInfo::CrossOriginEmbedderPolicy aLoadingEmbedderPolicy) + : mLoadingPrincipal(aLoadingPrincipal), + mTriggeringPrincipal(aTriggeringPrincipal), + mPrincipalToInherit(aPrincipalToInherit), + mTopLevelPrincipal(aTopLevelPrincipal), + mTopLevelStorageAreaPrincipal(aTopLevelStorageAreaPrincipal), + mResultPrincipalURI(aResultPrincipalURI), + mCookieJarSettings(aCookieJarSettings), + mCspToInherit(aCspToInherit), + mClientInfo(aClientInfo), + mReservedClientInfo(aReservedClientInfo), + mInitialClientInfo(aInitialClientInfo), + mController(aController), + mLoadingContext(do_GetWeakReference(aLoadingContext)), + mSecurityFlags(aSecurityFlags), + mSandboxFlags(aSandboxFlags), + mTriggeringSandboxFlags(aTriggeringSandboxFlags), + mInternalContentPolicyType(aContentPolicyType), + mTainting(aTainting), + mBlockAllMixedContent(aBlockAllMixedContent), + mUpgradeInsecureRequests(aUpgradeInsecureRequests), + mBrowserUpgradeInsecureRequests(aBrowserUpgradeInsecureRequests), + mBrowserDidUpgradeInsecureRequests(aBrowserDidUpgradeInsecureRequests), + mBrowserWouldUpgradeInsecureRequests( + aBrowserWouldUpgradeInsecureRequests), + mForceAllowDataURI(aForceAllowDataURI), + mAllowInsecureRedirectToDataURI(aAllowInsecureRedirectToDataURI), + mBypassCORSChecks(aBypassCORSChecks), + mSkipContentPolicyCheckForWebRequest( + aSkipContentPolicyCheckForWebRequest), + mOriginalFrameSrcLoad(aOriginalFrameSrcLoad), + mForceInheritPrincipalDropped(aForceInheritPrincipalDropped), + mInnerWindowID(aInnerWindowID), + mBrowsingContextID(aBrowsingContextID), + mFrameBrowsingContextID(aFrameBrowsingContextID), + mInitialSecurityCheckDone(aInitialSecurityCheckDone), + mIsThirdPartyContext(aIsThirdPartyContext), + mIsThirdPartyContextToTopWindow(aIsThirdPartyContextToTopWindow), + mIsFormSubmission(aIsFormSubmission), + mSendCSPViolationEvents(aSendCSPViolationEvents), + mOriginAttributes(aOriginAttributes), + mRedirectChainIncludingInternalRedirects( + std::move(aRedirectChainIncludingInternalRedirects)), + mRedirectChain(std::move(aRedirectChain)), + mAncestorPrincipals(std::move(aAncestorPrincipals)), + mAncestorBrowsingContextIDs(aAncestorBrowsingContextIDs.Clone()), + mCorsUnsafeHeaders(aCorsUnsafeHeaders.Clone()), + mRequestBlockingReason(aRequestBlockingReason), + mForcePreflight(aForcePreflight), + mIsPreflight(aIsPreflight), + mLoadTriggeredFromExternal(aLoadTriggeredFromExternal), + mServiceWorkerTaintingSynthesized(aServiceWorkerTaintingSynthesized), + mDocumentHasUserInteracted(aDocumentHasUserInteracted), + mAllowListFutureDocumentsCreatedFromThisRedirectChain( + aAllowListFutureDocumentsCreatedFromThisRedirectChain), + mCspNonce(aCspNonce), + mSkipContentSniffing(aSkipContentSniffing), + mHttpsOnlyStatus(aHttpsOnlyStatus), + mHasValidUserGestureActivation(aHasValidUserGestureActivation), + mAllowDeprecatedSystemRequests(aAllowDeprecatedSystemRequests), + mIsInDevToolsContext(aIsInDevToolsContext), + mParserCreatedScript(aParserCreatedScript), + mHasStoragePermission(aHasStoragePermission), + mIsFromProcessingFrameAttributes(false), + mLoadingEmbedderPolicy(aLoadingEmbedderPolicy) { + // Only top level TYPE_DOCUMENT loads can have a null loadingPrincipal + MOZ_ASSERT(mLoadingPrincipal || + aContentPolicyType == nsIContentPolicy::TYPE_DOCUMENT); + MOZ_ASSERT(mTriggeringPrincipal); +} + +// static +void LoadInfo::ComputeAncestors( + CanonicalBrowsingContext* aBC, + nsTArray<nsCOMPtr<nsIPrincipal>>& aAncestorPrincipals, + nsTArray<uint64_t>& aBrowsingContextIDs) { + MOZ_ASSERT(aAncestorPrincipals.IsEmpty()); + MOZ_ASSERT(aBrowsingContextIDs.IsEmpty()); + CanonicalBrowsingContext* ancestorBC = aBC; + // Iterate over ancestor WindowGlobalParents, collecting principals and outer + // window IDs. + while (WindowGlobalParent* ancestorWGP = + ancestorBC->GetParentWindowContext()) { + ancestorBC = ancestorWGP->BrowsingContext(); + + nsCOMPtr<nsIPrincipal> parentPrincipal = ancestorWGP->DocumentPrincipal(); + MOZ_ASSERT(parentPrincipal, "Ancestor principal is null"); + aAncestorPrincipals.AppendElement(parentPrincipal.forget()); + aBrowsingContextIDs.AppendElement(ancestorBC->Id()); + } +} +void LoadInfo::ComputeIsThirdPartyContext(nsPIDOMWindowOuter* aOuterWindow) { + ExtContentPolicyType type = + nsContentUtils::InternalContentPolicyTypeToExternal( + mInternalContentPolicyType); + if (type == ExtContentPolicy::TYPE_DOCUMENT) { + // Top-level loads are never third-party. + mIsThirdPartyContext = false; + return; + } + + nsCOMPtr<mozIThirdPartyUtil> util(do_GetService(THIRDPARTYUTIL_CONTRACTID)); + if (NS_WARN_IF(!util)) { + return; + } + + util->IsThirdPartyWindow(aOuterWindow, nullptr, &mIsThirdPartyContext); +} + +void LoadInfo::ComputeIsThirdPartyContext(dom::WindowGlobalParent* aGlobal) { + if (nsILoadInfo::GetExternalContentPolicyType() == + ExtContentPolicy::TYPE_DOCUMENT) { + // Top-level loads are never third-party. + mIsThirdPartyContext = false; + return; + } + + ThirdPartyUtil* thirdPartyUtil = ThirdPartyUtil::GetInstance(); + if (!thirdPartyUtil) { + return; + } + thirdPartyUtil->IsThirdPartyGlobal(aGlobal, &mIsThirdPartyContext); +} + +NS_IMPL_ISUPPORTS(LoadInfo, nsILoadInfo) + +already_AddRefed<nsILoadInfo> LoadInfo::Clone() const { + RefPtr<LoadInfo> copy(new LoadInfo(*this)); + return copy.forget(); +} + +already_AddRefed<nsILoadInfo> LoadInfo::CloneWithNewSecFlags( + nsSecurityFlags aSecurityFlags) const { + RefPtr<LoadInfo> copy(new LoadInfo(*this)); + copy->mSecurityFlags = aSecurityFlags; + return copy.forget(); +} + +already_AddRefed<nsILoadInfo> LoadInfo::CloneForNewRequest() const { + RefPtr<LoadInfo> copy(new LoadInfo(*this)); + copy->mInitialSecurityCheckDone = false; + copy->mRedirectChainIncludingInternalRedirects.Clear(); + copy->mRedirectChain.Clear(); + copy->mResultPrincipalURI = nullptr; + return copy.forget(); +} + +NS_IMETHODIMP +LoadInfo::GetLoadingPrincipal(nsIPrincipal** aLoadingPrincipal) { + NS_IF_ADDREF(*aLoadingPrincipal = mLoadingPrincipal); + return NS_OK; +} + +nsIPrincipal* LoadInfo::VirtualGetLoadingPrincipal() { + return mLoadingPrincipal; +} + +NS_IMETHODIMP +LoadInfo::GetTriggeringPrincipal(nsIPrincipal** aTriggeringPrincipal) { + *aTriggeringPrincipal = do_AddRef(mTriggeringPrincipal).take(); + return NS_OK; +} + +nsIPrincipal* LoadInfo::TriggeringPrincipal() { return mTriggeringPrincipal; } + +NS_IMETHODIMP +LoadInfo::GetPrincipalToInherit(nsIPrincipal** aPrincipalToInherit) { + NS_IF_ADDREF(*aPrincipalToInherit = mPrincipalToInherit); + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetPrincipalToInherit(nsIPrincipal* aPrincipalToInherit) { + MOZ_ASSERT(aPrincipalToInherit, "must be a valid principal to inherit"); + mPrincipalToInherit = aPrincipalToInherit; + return NS_OK; +} + +nsIPrincipal* LoadInfo::PrincipalToInherit() { return mPrincipalToInherit; } + +nsIPrincipal* LoadInfo::FindPrincipalToInherit(nsIChannel* aChannel) { + if (mPrincipalToInherit) { + return mPrincipalToInherit; + } + + nsCOMPtr<nsIURI> uri = mResultPrincipalURI; + if (!uri) { + Unused << aChannel->GetOriginalURI(getter_AddRefs(uri)); + } + + auto prin = BasePrincipal::Cast(mTriggeringPrincipal); + return prin->PrincipalToInherit(uri); +} + +nsIPrincipal* LoadInfo::GetSandboxedLoadingPrincipal() { + if (!(mSandboxFlags & SANDBOXED_ORIGIN)) { + return nullptr; + } + + if (!mSandboxedLoadingPrincipal) { + if (mLoadingPrincipal) { + mSandboxedLoadingPrincipal = + NullPrincipal::CreateWithInheritedAttributes(mLoadingPrincipal); + } else { + OriginAttributes attrs(mOriginAttributes); + mSandboxedLoadingPrincipal = NullPrincipal::Create(attrs); + } + } + MOZ_ASSERT(mSandboxedLoadingPrincipal); + + return mSandboxedLoadingPrincipal; +} + +nsIPrincipal* LoadInfo::GetTopLevelPrincipal() { return mTopLevelPrincipal; } + +nsIPrincipal* LoadInfo::GetTopLevelStorageAreaPrincipal() { + return mTopLevelStorageAreaPrincipal; +} + +NS_IMETHODIMP +LoadInfo::GetLoadingDocument(Document** aResult) { + if (nsCOMPtr<nsINode> node = do_QueryReferent(mLoadingContext)) { + RefPtr<Document> context = node->OwnerDoc(); + context.forget(aResult); + } + return NS_OK; +} + +nsINode* LoadInfo::LoadingNode() { + nsCOMPtr<nsINode> node = do_QueryReferent(mLoadingContext); + return node; +} + +already_AddRefed<nsISupports> LoadInfo::ContextForTopLevelLoad() { + // Most likely you want to query LoadingNode() instead of + // ContextForTopLevelLoad() if this assertion fires. + MOZ_ASSERT(mInternalContentPolicyType == nsIContentPolicy::TYPE_DOCUMENT, + "should only query this context for top level document loads"); + nsCOMPtr<nsISupports> context = do_QueryReferent(mContextForTopLevelLoad); + return context.forget(); +} + +already_AddRefed<nsISupports> LoadInfo::GetLoadingContext() { + nsCOMPtr<nsISupports> context; + if (mInternalContentPolicyType == nsIContentPolicy::TYPE_DOCUMENT) { + context = ContextForTopLevelLoad(); + } else { + context = LoadingNode(); + } + return context.forget(); +} + +NS_IMETHODIMP +LoadInfo::GetLoadingContextXPCOM(nsISupports** aResult) { + nsCOMPtr<nsISupports> context = GetLoadingContext(); + context.forget(aResult); + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetSecurityFlags(nsSecurityFlags* aResult) { + *aResult = mSecurityFlags; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetSandboxFlags(uint32_t* aResult) { + *aResult = mSandboxFlags; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetTriggeringSandboxFlags(uint32_t* aResult) { + *aResult = mTriggeringSandboxFlags; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetTriggeringSandboxFlags(uint32_t aFlags) { + mTriggeringSandboxFlags = aFlags; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetSecurityMode(uint32_t* aFlags) { + *aFlags = (mSecurityFlags & + (nsILoadInfo::SEC_REQUIRE_SAME_ORIGIN_INHERITS_SEC_CONTEXT | + nsILoadInfo::SEC_REQUIRE_SAME_ORIGIN_DATA_IS_BLOCKED | + nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_INHERITS_SEC_CONTEXT | + nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL | + nsILoadInfo::SEC_REQUIRE_CORS_INHERITS_SEC_CONTEXT)); + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetIsInThirdPartyContext(bool* aIsInThirdPartyContext) { + *aIsInThirdPartyContext = mIsThirdPartyContext; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetIsInThirdPartyContext(bool aIsInThirdPartyContext) { + mIsThirdPartyContext = aIsInThirdPartyContext; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetIsThirdPartyContextToTopWindow( + bool* aIsThirdPartyContextToTopWindow) { + *aIsThirdPartyContextToTopWindow = mIsThirdPartyContextToTopWindow; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetIsThirdPartyContextToTopWindow( + bool aIsThirdPartyContextToTopWindow) { + mIsThirdPartyContextToTopWindow = aIsThirdPartyContextToTopWindow; + return NS_OK; +} + +static const uint32_t sCookiePolicyMask = + nsILoadInfo::SEC_COOKIES_DEFAULT | nsILoadInfo::SEC_COOKIES_INCLUDE | + nsILoadInfo::SEC_COOKIES_SAME_ORIGIN | nsILoadInfo::SEC_COOKIES_OMIT; + +NS_IMETHODIMP +LoadInfo::GetCookiePolicy(uint32_t* aResult) { + uint32_t policy = mSecurityFlags & sCookiePolicyMask; + if (policy == nsILoadInfo::SEC_COOKIES_DEFAULT) { + policy = (mSecurityFlags & SEC_REQUIRE_CORS_INHERITS_SEC_CONTEXT) + ? nsILoadInfo::SEC_COOKIES_SAME_ORIGIN + : nsILoadInfo::SEC_COOKIES_INCLUDE; + } + + *aResult = policy; + return NS_OK; +} + +namespace { + +already_AddRefed<nsICookieJarSettings> CreateCookieJarSettings( + nsContentPolicyType aContentPolicyType) { + if (StaticPrefs::network_cookieJarSettings_unblocked_for_testing()) { + return CookieJarSettings::Create(); + } + + // These contentPolictTypes require a real CookieJarSettings because favicon + // and save-as requests must send cookies. Anything else should not + // send/receive cookies. + if (aContentPolicyType == nsIContentPolicy::TYPE_INTERNAL_IMAGE_FAVICON || + aContentPolicyType == nsIContentPolicy::TYPE_SAVEAS_DOWNLOAD) { + return CookieJarSettings::Create(); + } + + return CookieJarSettings::GetBlockingAll(); +} + +} // namespace + +NS_IMETHODIMP +LoadInfo::GetCookieJarSettings(nsICookieJarSettings** aCookieJarSettings) { + if (!mCookieJarSettings) { + mCookieJarSettings = CreateCookieJarSettings(mInternalContentPolicyType); + } + + nsCOMPtr<nsICookieJarSettings> cookieJarSettings = mCookieJarSettings; + cookieJarSettings.forget(aCookieJarSettings); + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetCookieJarSettings(nsICookieJarSettings* aCookieJarSettings) { + MOZ_ASSERT(aCookieJarSettings); + // We allow the overwrite of CookieJarSettings. + mCookieJarSettings = aCookieJarSettings; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetHasStoragePermission(bool* aHasStoragePermission) { + *aHasStoragePermission = mHasStoragePermission; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetHasStoragePermission(bool aHasStoragePermission) { + mHasStoragePermission = aHasStoragePermission; + return NS_OK; +} + +void LoadInfo::SetIncludeCookiesSecFlag() { + MOZ_ASSERT((mSecurityFlags & sCookiePolicyMask) == + nsILoadInfo::SEC_COOKIES_DEFAULT); + mSecurityFlags = + (mSecurityFlags & ~sCookiePolicyMask) | nsILoadInfo::SEC_COOKIES_INCLUDE; +} + +NS_IMETHODIMP +LoadInfo::GetForceInheritPrincipal(bool* aInheritPrincipal) { + *aInheritPrincipal = + (mSecurityFlags & nsILoadInfo::SEC_FORCE_INHERIT_PRINCIPAL); + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetForceInheritPrincipalOverruleOwner(bool* aInheritPrincipal) { + *aInheritPrincipal = + (mSecurityFlags & + nsILoadInfo::SEC_FORCE_INHERIT_PRINCIPAL_OVERRULE_OWNER); + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetLoadingSandboxed(bool* aLoadingSandboxed) { + *aLoadingSandboxed = (mSandboxFlags & SANDBOXED_ORIGIN); + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetAboutBlankInherits(bool* aResult) { + *aResult = (mSecurityFlags & nsILoadInfo::SEC_ABOUT_BLANK_INHERITS); + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetAllowChrome(bool* aResult) { + *aResult = (mSecurityFlags & nsILoadInfo::SEC_ALLOW_CHROME); + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetDisallowScript(bool* aResult) { + *aResult = (mSecurityFlags & nsILoadInfo::SEC_DISALLOW_SCRIPT); + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetDontFollowRedirects(bool* aResult) { + *aResult = (mSecurityFlags & nsILoadInfo::SEC_DONT_FOLLOW_REDIRECTS); + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetLoadErrorPage(bool* aResult) { + *aResult = (mSecurityFlags & nsILoadInfo::SEC_LOAD_ERROR_PAGE); + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetIsFormSubmission(bool* aResult) { + *aResult = mIsFormSubmission; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetIsFormSubmission(bool aValue) { + mIsFormSubmission = aValue; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetSendCSPViolationEvents(bool* aResult) { + *aResult = mSendCSPViolationEvents; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetSendCSPViolationEvents(bool aValue) { + mSendCSPViolationEvents = aValue; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetExternalContentPolicyType(nsContentPolicyType* aResult) { + // We have to use nsContentPolicyType because ExtContentPolicyType is not + // visible from xpidl. + *aResult = static_cast<nsContentPolicyType>( + nsContentUtils::InternalContentPolicyTypeToExternal( + mInternalContentPolicyType)); + return NS_OK; +} + +nsContentPolicyType LoadInfo::InternalContentPolicyType() { + return mInternalContentPolicyType; +} + +NS_IMETHODIMP +LoadInfo::GetBlockAllMixedContent(bool* aResult) { + *aResult = mBlockAllMixedContent; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetUpgradeInsecureRequests(bool* aResult) { + *aResult = mUpgradeInsecureRequests; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetBrowserUpgradeInsecureRequests(bool* aResult) { + *aResult = mBrowserUpgradeInsecureRequests; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetBrowserDidUpgradeInsecureRequests(bool* aResult) { + *aResult = mBrowserDidUpgradeInsecureRequests; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetBrowserWouldUpgradeInsecureRequests(bool* aResult) { + *aResult = mBrowserWouldUpgradeInsecureRequests; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetForceAllowDataURI(bool aForceAllowDataURI) { + MOZ_ASSERT(!mForceAllowDataURI || + mInternalContentPolicyType == nsIContentPolicy::TYPE_DOCUMENT, + "can only allow data URI navigation for TYPE_DOCUMENT"); + mForceAllowDataURI = aForceAllowDataURI; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetForceAllowDataURI(bool* aForceAllowDataURI) { + *aForceAllowDataURI = mForceAllowDataURI; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetAllowInsecureRedirectToDataURI( + bool aAllowInsecureRedirectToDataURI) { + mAllowInsecureRedirectToDataURI = aAllowInsecureRedirectToDataURI; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetAllowInsecureRedirectToDataURI( + bool* aAllowInsecureRedirectToDataURI) { + *aAllowInsecureRedirectToDataURI = mAllowInsecureRedirectToDataURI; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetBypassCORSChecks(bool aBypassCORSChecks) { + mBypassCORSChecks = aBypassCORSChecks; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetBypassCORSChecks(bool* aBypassCORSChecks) { + *aBypassCORSChecks = mBypassCORSChecks; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetSkipContentPolicyCheckForWebRequest(bool aSkip) { + mSkipContentPolicyCheckForWebRequest = aSkip; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetSkipContentPolicyCheckForWebRequest(bool* aSkip) { + *aSkip = mSkipContentPolicyCheckForWebRequest; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetOriginalFrameSrcLoad(bool aOriginalFrameSrcLoad) { + mOriginalFrameSrcLoad = aOriginalFrameSrcLoad; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetOriginalFrameSrcLoad(bool* aOriginalFrameSrcLoad) { + *aOriginalFrameSrcLoad = mOriginalFrameSrcLoad; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetForceInheritPrincipalDropped(bool* aResult) { + *aResult = mForceInheritPrincipalDropped; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetInnerWindowID(uint64_t* aResult) { + *aResult = mInnerWindowID; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetBrowsingContextID(uint64_t* aResult) { + *aResult = mBrowsingContextID; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetFrameBrowsingContextID(uint64_t* aResult) { + *aResult = mFrameBrowsingContextID; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetTargetBrowsingContextID(uint64_t* aResult) { + return (nsILoadInfo::GetExternalContentPolicyType() == + ExtContentPolicy::TYPE_SUBDOCUMENT) + ? GetFrameBrowsingContextID(aResult) + : GetBrowsingContextID(aResult); +} + +NS_IMETHODIMP +LoadInfo::GetBrowsingContext(dom::BrowsingContext** aResult) { + *aResult = BrowsingContext::Get(mBrowsingContextID).take(); + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetFrameBrowsingContext(dom::BrowsingContext** aResult) { + *aResult = BrowsingContext::Get(mFrameBrowsingContextID).take(); + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetTargetBrowsingContext(dom::BrowsingContext** aResult) { + uint64_t targetBrowsingContextID = 0; + MOZ_ALWAYS_SUCCEEDS(GetTargetBrowsingContextID(&targetBrowsingContextID)); + *aResult = BrowsingContext::Get(targetBrowsingContextID).take(); + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetScriptableOriginAttributes( + JSContext* aCx, JS::MutableHandle<JS::Value> aOriginAttributes) { + if (NS_WARN_IF(!ToJSValue(aCx, mOriginAttributes, aOriginAttributes))) { + return NS_ERROR_FAILURE; + } + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::ResetPrincipalToInheritToNullPrincipal() { + // take the originAttributes from the LoadInfo and create + // a new NullPrincipal using those origin attributes. + nsCOMPtr<nsIPrincipal> newNullPrincipal = + NullPrincipal::Create(mOriginAttributes); + + mPrincipalToInherit = newNullPrincipal; + + // setting SEC_FORCE_INHERIT_PRINCIPAL_OVERRULE_OWNER will overrule + // any non null owner set on the channel and will return the principal + // form the loadinfo instead. + mSecurityFlags |= SEC_FORCE_INHERIT_PRINCIPAL_OVERRULE_OWNER; + + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetScriptableOriginAttributes( + JSContext* aCx, JS::Handle<JS::Value> aOriginAttributes) { + OriginAttributes attrs; + if (!aOriginAttributes.isObject() || !attrs.Init(aCx, aOriginAttributes)) { + return NS_ERROR_INVALID_ARG; + } + + mOriginAttributes = attrs; + return NS_OK; +} + +nsresult LoadInfo::GetOriginAttributes( + mozilla::OriginAttributes* aOriginAttributes) { + NS_ENSURE_ARG(aOriginAttributes); + *aOriginAttributes = mOriginAttributes; + return NS_OK; +} + +nsresult LoadInfo::SetOriginAttributes( + const mozilla::OriginAttributes& aOriginAttributes) { + mOriginAttributes = aOriginAttributes; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetInitialSecurityCheckDone(bool aInitialSecurityCheckDone) { + // Indicates whether the channel was ever evaluated by the + // ContentSecurityManager. Once set to true, this flag must + // remain true throughout the lifetime of the channel. + // Setting it to anything else than true will be discarded. + MOZ_ASSERT(aInitialSecurityCheckDone, + "aInitialSecurityCheckDone must be true"); + mInitialSecurityCheckDone = + mInitialSecurityCheckDone || aInitialSecurityCheckDone; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetInitialSecurityCheckDone(bool* aResult) { + *aResult = mInitialSecurityCheckDone; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::AppendRedirectHistoryEntry(nsIRedirectHistoryEntry* aEntry, + bool aIsInternalRedirect) { + NS_ENSURE_ARG(aEntry); + MOZ_ASSERT(NS_IsMainThread()); + + mRedirectChainIncludingInternalRedirects.AppendElement(aEntry); + if (!aIsInternalRedirect) { + mRedirectChain.AppendElement(aEntry); + } + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetRedirects(JSContext* aCx, JS::MutableHandle<JS::Value> aRedirects, + const RedirectHistoryArray& aArray) { + JS::Rooted<JSObject*> redirects(aCx, + JS::NewArrayObject(aCx, aArray.Length())); + NS_ENSURE_TRUE(redirects, NS_ERROR_OUT_OF_MEMORY); + + JS::Rooted<JSObject*> global(aCx, JS::CurrentGlobalOrNull(aCx)); + NS_ENSURE_TRUE(global, NS_ERROR_UNEXPECTED); + + nsCOMPtr<nsIXPConnect> xpc = nsIXPConnect::XPConnect(); + + for (size_t idx = 0; idx < aArray.Length(); idx++) { + JS::RootedObject jsobj(aCx); + nsresult rv = + xpc->WrapNative(aCx, global, aArray[idx], + NS_GET_IID(nsIRedirectHistoryEntry), jsobj.address()); + NS_ENSURE_SUCCESS(rv, rv); + NS_ENSURE_STATE(jsobj); + + bool rc = JS_DefineElement(aCx, redirects, idx, jsobj, JSPROP_ENUMERATE); + NS_ENSURE_TRUE(rc, NS_ERROR_UNEXPECTED); + } + + aRedirects.setObject(*redirects); + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetRedirectChainIncludingInternalRedirects( + JSContext* aCx, JS::MutableHandle<JS::Value> aChain) { + return GetRedirects(aCx, aChain, mRedirectChainIncludingInternalRedirects); +} + +const RedirectHistoryArray& +LoadInfo::RedirectChainIncludingInternalRedirects() { + return mRedirectChainIncludingInternalRedirects; +} + +NS_IMETHODIMP +LoadInfo::GetRedirectChain(JSContext* aCx, + JS::MutableHandle<JS::Value> aChain) { + return GetRedirects(aCx, aChain, mRedirectChain); +} + +const RedirectHistoryArray& LoadInfo::RedirectChain() { return mRedirectChain; } + +const nsTArray<nsCOMPtr<nsIPrincipal>>& LoadInfo::AncestorPrincipals() { + return mAncestorPrincipals; +} + +const nsTArray<uint64_t>& LoadInfo::AncestorBrowsingContextIDs() { + return mAncestorBrowsingContextIDs; +} + +void LoadInfo::SetCorsPreflightInfo(const nsTArray<nsCString>& aHeaders, + bool aForcePreflight) { + MOZ_ASSERT(GetSecurityMode() == + nsILoadInfo::SEC_REQUIRE_CORS_INHERITS_SEC_CONTEXT); + MOZ_ASSERT(!mInitialSecurityCheckDone); + mCorsUnsafeHeaders = aHeaders.Clone(); + mForcePreflight = aForcePreflight; +} + +const nsTArray<nsCString>& LoadInfo::CorsUnsafeHeaders() { + return mCorsUnsafeHeaders; +} + +NS_IMETHODIMP +LoadInfo::GetForcePreflight(bool* aForcePreflight) { + *aForcePreflight = mForcePreflight; + return NS_OK; +} + +void LoadInfo::SetIsPreflight() { + MOZ_ASSERT(GetSecurityMode() == + nsILoadInfo::SEC_REQUIRE_CORS_INHERITS_SEC_CONTEXT); + MOZ_ASSERT(!mInitialSecurityCheckDone); + mIsPreflight = true; +} + +void LoadInfo::SetUpgradeInsecureRequests(bool aValue) { + mUpgradeInsecureRequests = aValue; +} + +void LoadInfo::SetBrowserUpgradeInsecureRequests() { + mBrowserUpgradeInsecureRequests = true; +} + +NS_IMETHODIMP +LoadInfo::SetBrowserDidUpgradeInsecureRequests( + bool aBrowserDidUpgradeInsecureRequests) { + mBrowserDidUpgradeInsecureRequests = aBrowserDidUpgradeInsecureRequests; + return NS_OK; +} + +void LoadInfo::SetBrowserWouldUpgradeInsecureRequests() { + mBrowserWouldUpgradeInsecureRequests = true; +} + +NS_IMETHODIMP +LoadInfo::GetIsPreflight(bool* aIsPreflight) { + *aIsPreflight = mIsPreflight; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetLoadTriggeredFromExternal(bool aLoadTriggeredFromExternal) { + MOZ_ASSERT(!aLoadTriggeredFromExternal || + mInternalContentPolicyType == nsIContentPolicy::TYPE_DOCUMENT, + "can only set load triggered from external for TYPE_DOCUMENT"); + mLoadTriggeredFromExternal = aLoadTriggeredFromExternal; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetLoadTriggeredFromExternal(bool* aLoadTriggeredFromExternal) { + *aLoadTriggeredFromExternal = mLoadTriggeredFromExternal; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetServiceWorkerTaintingSynthesized( + bool* aServiceWorkerTaintingSynthesized) { + MOZ_ASSERT(aServiceWorkerTaintingSynthesized); + *aServiceWorkerTaintingSynthesized = mServiceWorkerTaintingSynthesized; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetTainting(uint32_t* aTaintingOut) { + MOZ_ASSERT(aTaintingOut); + *aTaintingOut = static_cast<uint32_t>(mTainting); + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::MaybeIncreaseTainting(uint32_t aTainting) { + NS_ENSURE_ARG(aTainting <= TAINTING_OPAQUE); + + // Skip if the tainting has been set by the service worker. + if (mServiceWorkerTaintingSynthesized) { + return NS_OK; + } + + LoadTainting tainting = static_cast<LoadTainting>(aTainting); + if (tainting > mTainting) { + mTainting = tainting; + } + return NS_OK; +} + +void LoadInfo::SynthesizeServiceWorkerTainting(LoadTainting aTainting) { + MOZ_DIAGNOSTIC_ASSERT(aTainting <= LoadTainting::Opaque); + mTainting = aTainting; + + // Flag to prevent the tainting from being increased. + mServiceWorkerTaintingSynthesized = true; +} + +NS_IMETHODIMP +LoadInfo::GetDocumentHasUserInteracted(bool* aDocumentHasUserInteracted) { + MOZ_ASSERT(aDocumentHasUserInteracted); + *aDocumentHasUserInteracted = mDocumentHasUserInteracted; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetDocumentHasUserInteracted(bool aDocumentHasUserInteracted) { + mDocumentHasUserInteracted = aDocumentHasUserInteracted; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetAllowListFutureDocumentsCreatedFromThisRedirectChain( + bool* aValue) { + MOZ_ASSERT(aValue); + *aValue = mAllowListFutureDocumentsCreatedFromThisRedirectChain; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetAllowListFutureDocumentsCreatedFromThisRedirectChain(bool aValue) { + mAllowListFutureDocumentsCreatedFromThisRedirectChain = aValue; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetCspNonce(nsAString& aCspNonce) { + aCspNonce = mCspNonce; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetCspNonce(const nsAString& aCspNonce) { + MOZ_ASSERT(!mInitialSecurityCheckDone, + "setting the nonce is only allowed before any sec checks"); + mCspNonce = aCspNonce; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetSkipContentSniffing(bool* aSkipContentSniffing) { + *aSkipContentSniffing = mSkipContentSniffing; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetSkipContentSniffing(bool aSkipContentSniffing) { + mSkipContentSniffing = aSkipContentSniffing; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetHttpsOnlyStatus(uint32_t* aHttpsOnlyStatus) { + *aHttpsOnlyStatus = mHttpsOnlyStatus; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetHttpsOnlyStatus(uint32_t aHttpsOnlyStatus) { + mHttpsOnlyStatus = aHttpsOnlyStatus; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetHasValidUserGestureActivation( + bool* aHasValidUserGestureActivation) { + *aHasValidUserGestureActivation = mHasValidUserGestureActivation; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetHasValidUserGestureActivation( + bool aHasValidUserGestureActivation) { + mHasValidUserGestureActivation = aHasValidUserGestureActivation; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetAllowDeprecatedSystemRequests( + bool* aAllowDeprecatedSystemRequests) { + *aAllowDeprecatedSystemRequests = mAllowDeprecatedSystemRequests; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetAllowDeprecatedSystemRequests( + bool aAllowDeprecatedSystemRequests) { + mAllowDeprecatedSystemRequests = aAllowDeprecatedSystemRequests; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetIsInDevToolsContext(bool* aIsInDevToolsContext) { + *aIsInDevToolsContext = mIsInDevToolsContext; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetIsInDevToolsContext(bool aIsInDevToolsContext) { + mIsInDevToolsContext = aIsInDevToolsContext; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetParserCreatedScript(bool* aParserCreatedScript) { + *aParserCreatedScript = mParserCreatedScript; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetParserCreatedScript(bool aParserCreatedScript) { + mParserCreatedScript = aParserCreatedScript; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetIsTopLevelLoad(bool* aResult) { + RefPtr<dom::BrowsingContext> bc; + GetTargetBrowsingContext(getter_AddRefs(bc)); + *aResult = !bc || bc->IsTop(); + return NS_OK; +} + +void LoadInfo::SetIsFromProcessingFrameAttributes() { + mIsFromProcessingFrameAttributes = true; +} + +NS_IMETHODIMP +LoadInfo::GetIsFromProcessingFrameAttributes( + bool* aIsFromProcessingFrameAttributes) { + MOZ_ASSERT(aIsFromProcessingFrameAttributes); + *aIsFromProcessingFrameAttributes = mIsFromProcessingFrameAttributes; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetResultPrincipalURI(nsIURI** aURI) { + NS_IF_ADDREF(*aURI = mResultPrincipalURI); + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetResultPrincipalURI(nsIURI* aURI) { + mResultPrincipalURI = aURI; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetRequestBlockingReason(uint32_t aReason) { + mRequestBlockingReason = aReason; + return NS_OK; +} +NS_IMETHODIMP +LoadInfo::GetRequestBlockingReason(uint32_t* aReason) { + *aReason = mRequestBlockingReason; + return NS_OK; +} + +void LoadInfo::SetClientInfo(const ClientInfo& aClientInfo) { + mClientInfo.emplace(aClientInfo); +} + +const Maybe<ClientInfo>& LoadInfo::GetClientInfo() { return mClientInfo; } + +void LoadInfo::GiveReservedClientSource( + UniquePtr<ClientSource>&& aClientSource) { + MOZ_DIAGNOSTIC_ASSERT(aClientSource); + mReservedClientSource = std::move(aClientSource); + SetReservedClientInfo(mReservedClientSource->Info()); +} + +UniquePtr<ClientSource> LoadInfo::TakeReservedClientSource() { + if (mReservedClientSource) { + // If the reserved ClientInfo was set due to a ClientSource being present, + // then clear that info object when the ClientSource is taken. + mReservedClientInfo.reset(); + } + return std::move(mReservedClientSource); +} + +void LoadInfo::SetReservedClientInfo(const ClientInfo& aClientInfo) { + MOZ_DIAGNOSTIC_ASSERT(mInitialClientInfo.isNothing()); + // Treat assignments of the same value as a no-op. The emplace below + // will normally assert when overwriting an existing value. + if (mReservedClientInfo.isSome() && + mReservedClientInfo.ref() == aClientInfo) { + return; + } + mReservedClientInfo.emplace(aClientInfo); +} + +void LoadInfo::OverrideReservedClientInfoInParent( + const ClientInfo& aClientInfo) { + // This should only be called to handle redirects in the parent process. + MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default); + + mInitialClientInfo.reset(); + mReservedClientInfo.reset(); + mReservedClientInfo.emplace(aClientInfo); +} + +const Maybe<ClientInfo>& LoadInfo::GetReservedClientInfo() { + return mReservedClientInfo; +} + +void LoadInfo::SetInitialClientInfo(const ClientInfo& aClientInfo) { + MOZ_DIAGNOSTIC_ASSERT(!mReservedClientSource); + MOZ_DIAGNOSTIC_ASSERT(mReservedClientInfo.isNothing()); + // Treat assignments of the same value as a no-op. The emplace below + // will normally assert when overwriting an existing value. + if (mInitialClientInfo.isSome() && mInitialClientInfo.ref() == aClientInfo) { + return; + } + mInitialClientInfo.emplace(aClientInfo); +} + +const Maybe<ClientInfo>& LoadInfo::GetInitialClientInfo() { + return mInitialClientInfo; +} + +void LoadInfo::SetController(const ServiceWorkerDescriptor& aServiceWorker) { + mController.emplace(aServiceWorker); +} + +void LoadInfo::ClearController() { mController.reset(); } + +const Maybe<ServiceWorkerDescriptor>& LoadInfo::GetController() { + return mController; +} + +void LoadInfo::SetPerformanceStorage(PerformanceStorage* aPerformanceStorage) { + mPerformanceStorage = aPerformanceStorage; +} + +PerformanceStorage* LoadInfo::GetPerformanceStorage() { + if (mPerformanceStorage) { + return mPerformanceStorage; + } + + auto* innerWindow = nsGlobalWindowInner::GetInnerWindowWithId(mInnerWindowID); + if (!innerWindow) { + return nullptr; + } + + if (!TriggeringPrincipal()->Equals(innerWindow->GetPrincipal())) { + return nullptr; + } + + if (nsILoadInfo::GetExternalContentPolicyType() == + ExtContentPolicy::TYPE_SUBDOCUMENT && + !GetIsFromProcessingFrameAttributes()) { + // We only report loads caused by processing the attributes of the + // browsing context container. + return nullptr; + } + + mozilla::dom::Performance* performance = innerWindow->GetPerformance(); + if (!performance) { + return nullptr; + } + + return performance->AsPerformanceStorage(); +} + +NS_IMETHODIMP +LoadInfo::GetCspEventListener(nsICSPEventListener** aCSPEventListener) { + NS_IF_ADDREF(*aCSPEventListener = mCSPEventListener); + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetCspEventListener(nsICSPEventListener* aCSPEventListener) { + mCSPEventListener = aCSPEventListener; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetInternalContentPolicyType(nsContentPolicyType* aResult) { + *aResult = mInternalContentPolicyType; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::GetLoadingEmbedderPolicy( + nsILoadInfo::CrossOriginEmbedderPolicy* aOutPolicy) { + *aOutPolicy = mLoadingEmbedderPolicy; + return NS_OK; +} + +NS_IMETHODIMP +LoadInfo::SetLoadingEmbedderPolicy( + nsILoadInfo::CrossOriginEmbedderPolicy aPolicy) { + mLoadingEmbedderPolicy = aPolicy; + return NS_OK; +} + +already_AddRefed<nsIContentSecurityPolicy> LoadInfo::GetCsp() { + // Before querying the CSP from the client we have to check if the + // triggeringPrincipal originates from an addon and potentially + // overrides the CSP stored within the client. + if (mLoadingPrincipal && BasePrincipal::Cast(mTriggeringPrincipal) + ->OverridesCSP(mLoadingPrincipal)) { + nsCOMPtr<nsIExpandedPrincipal> ep = do_QueryInterface(mTriggeringPrincipal); + nsCOMPtr<nsIContentSecurityPolicy> addonCSP; + if (ep) { + addonCSP = ep->GetCsp(); + } + return addonCSP.forget(); + } + + if (mClientInfo.isNothing()) { + return nullptr; + } + + nsCOMPtr<nsINode> node = do_QueryReferent(mLoadingContext); + RefPtr<Document> doc = node ? node->OwnerDoc() : nullptr; + + // If the client is of type window, then we return the cached CSP + // stored on the document instead of having to deserialize the CSP + // from the ClientInfo. + if (doc && mClientInfo->Type() == ClientType::Window) { + nsCOMPtr<nsIContentSecurityPolicy> docCSP = doc->GetCsp(); + return docCSP.forget(); + } + + Maybe<mozilla::ipc::CSPInfo> cspInfo = mClientInfo->GetCspInfo(); + if (cspInfo.isNothing()) { + return nullptr; + } + nsCOMPtr<nsIContentSecurityPolicy> clientCSP = + CSPInfoToCSP(cspInfo.ref(), doc); + return clientCSP.forget(); +} + +already_AddRefed<nsIContentSecurityPolicy> LoadInfo::GetPreloadCsp() { + if (mClientInfo.isNothing()) { + return nullptr; + } + + nsCOMPtr<nsINode> node = do_QueryReferent(mLoadingContext); + RefPtr<Document> doc = node ? node->OwnerDoc() : nullptr; + + // If the client is of type window, then we return the cached CSP + // stored on the document instead of having to deserialize the CSP + // from the ClientInfo. + if (doc && mClientInfo->Type() == ClientType::Window) { + nsCOMPtr<nsIContentSecurityPolicy> preloadCsp = doc->GetPreloadCsp(); + return preloadCsp.forget(); + } + + Maybe<mozilla::ipc::CSPInfo> cspInfo = mClientInfo->GetPreloadCspInfo(); + if (cspInfo.isNothing()) { + return nullptr; + } + nsCOMPtr<nsIContentSecurityPolicy> preloadCSP = + CSPInfoToCSP(cspInfo.ref(), doc); + return preloadCSP.forget(); +} + +already_AddRefed<nsIContentSecurityPolicy> LoadInfo::GetCspToInherit() { + nsCOMPtr<nsIContentSecurityPolicy> cspToInherit = mCspToInherit; + return cspToInherit.forget(); +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/LoadInfo.h b/netwerk/base/LoadInfo.h new file mode 100644 index 0000000000..5efa7332fa --- /dev/null +++ b/netwerk/base/LoadInfo.h @@ -0,0 +1,342 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +#ifndef mozilla_LoadInfo_h +#define mozilla_LoadInfo_h + +#include "nsIContentSecurityPolicy.h" +#include "nsILoadInfo.h" +#include "nsIPrincipal.h" +#include "nsIWeakReferenceUtils.h" // for nsWeakPtr +#include "nsIURI.h" +#include "nsContentUtils.h" +#include "nsString.h" +#include "nsTArray.h" + +#include "mozilla/BasePrincipal.h" +#include "mozilla/dom/ClientInfo.h" +#include "mozilla/dom/ServiceWorkerDescriptor.h" + +class nsDocShell; +class nsICookieJarSettings; +class nsINode; +class nsPIDOMWindowOuter; + +namespace mozilla { + +namespace dom { +class PerformanceStorage; +class XMLHttpRequestMainThread; +class CanonicalBrowsingContext; +class WindowGlobalParent; +} // namespace dom + +namespace net { +class LoadInfoArgs; +class LoadInfo; +} // namespace net + +namespace ipc { +// we have to forward declare that function so we can use it as a friend. +nsresult LoadInfoArgsToLoadInfo( + const Maybe<mozilla::net::LoadInfoArgs>& aLoadInfoArgs, + nsINode* aCspToInheritLoadingContext, net::LoadInfo** outLoadInfo); +} // namespace ipc + +namespace net { + +typedef nsTArray<nsCOMPtr<nsIRedirectHistoryEntry>> RedirectHistoryArray; + +/** + * Class that provides an nsILoadInfo implementation. + */ +class LoadInfo final : public nsILoadInfo { + template <typename T, typename... Args> + friend already_AddRefed<T> mozilla::MakeAndAddRef(Args&&... aArgs); + + public: + NS_DECL_ISUPPORTS + NS_DECL_NSILOADINFO + + // Used for TYPE_DOCUMENT load. + static already_AddRefed<LoadInfo> CreateForDocument( + dom::CanonicalBrowsingContext* aBrowsingContext, + nsIPrincipal* aTriggeringPrincipal, + const OriginAttributes& aOriginAttributes, nsSecurityFlags aSecurityFlags, + uint32_t aSandboxFlags); + + // Used for TYPE_FRAME or TYPE_IFRAME load. + static already_AddRefed<LoadInfo> CreateForFrame( + dom::CanonicalBrowsingContext* aBrowsingContext, + nsIPrincipal* aTriggeringPrincipal, nsSecurityFlags aSecurityFlags, + uint32_t aSandboxFlags); + + // Use for non-{TYPE_DOCUMENT|TYPE_FRAME|TYPE_IFRAME} load. + static already_AddRefed<LoadInfo> CreateForNonDocument( + dom::WindowGlobalParent* aParentWGP, nsIPrincipal* aTriggeringPrincipal, + nsContentPolicyType aContentPolicyType, nsSecurityFlags aSecurityFlags, + uint32_t aSandboxFlags); + + // aLoadingPrincipal MUST NOT BE NULL. + LoadInfo(nsIPrincipal* aLoadingPrincipal, nsIPrincipal* aTriggeringPrincipal, + nsINode* aLoadingContext, nsSecurityFlags aSecurityFlags, + nsContentPolicyType aContentPolicyType, + const Maybe<mozilla::dom::ClientInfo>& aLoadingClientInfo = + Maybe<mozilla::dom::ClientInfo>(), + const Maybe<mozilla::dom::ServiceWorkerDescriptor>& aController = + Maybe<mozilla::dom::ServiceWorkerDescriptor>(), + uint32_t aSandboxFlags = 0); + + // Constructor used for TYPE_DOCUMENT loads which have a different + // loadingContext than other loads. This ContextForTopLevelLoad is + // only used for content policy checks. + LoadInfo(nsPIDOMWindowOuter* aOuterWindow, nsIPrincipal* aTriggeringPrincipal, + nsISupports* aContextForTopLevelLoad, nsSecurityFlags aSecurityFlags, + uint32_t aSandboxFlags); + + private: + // Use factory function CreateForDocument + // Used for TYPE_DOCUMENT load. + LoadInfo(dom::CanonicalBrowsingContext* aBrowsingContext, + nsIPrincipal* aTriggeringPrincipal, + const OriginAttributes& aOriginAttributes, + nsSecurityFlags aSecurityFlags, uint32_t aSandboxFlags); + + // Use factory function CreateForFrame + // Used for TYPE_FRAME or TYPE_IFRAME load. + LoadInfo(dom::CanonicalBrowsingContext* aBrowsingContext, + nsIPrincipal* aTriggeringPrincipal, nsSecurityFlags aSecurityFlags, + uint32_t aSandboxFlags); + + // Used for loads initiated by DocumentLoadListener that are not TYPE_DOCUMENT + // | TYPE_FRAME | TYPE_FRAME. + LoadInfo(dom::WindowGlobalParent* aParentWGP, + nsIPrincipal* aTriggeringPrincipal, + nsContentPolicyType aContentPolicyType, + nsSecurityFlags aSecurityFlags, uint32_t aSandboxFlags); + + public: + // Compute a list of ancestor principals and BrowsingContext IDs. + // See methods AncestorPrincipals and AncestorBrowsingContextIDs + // in nsILoadInfo.idl for details. + static void ComputeAncestors( + dom::CanonicalBrowsingContext* aBC, + nsTArray<nsCOMPtr<nsIPrincipal>>& aAncestorPrincipals, + nsTArray<uint64_t>& aBrowsingContextIDs); + + // create an exact copy of the loadinfo + already_AddRefed<nsILoadInfo> Clone() const; + + // hands off!!! don't use CloneWithNewSecFlags unless you know + // exactly what you are doing - it should only be used within + // nsBaseChannel::Redirect() + already_AddRefed<nsILoadInfo> CloneWithNewSecFlags( + nsSecurityFlags aSecurityFlags) const; + // creates a copy of the loadinfo which is appropriate to use for a + // separate request. I.e. not for a redirect or an inner channel, but + // when a separate request is made with the same security properties. + already_AddRefed<nsILoadInfo> CloneForNewRequest() const; + + // The `nsContentPolicyType GetExternalContentPolicyType()` version in the + // base class is hidden by the implementation of + // `GetExternalContentPolicyType(nsContentPolicyType* aResult)` in + // LoadInfo.cpp. Explicit mark it visible. + using nsILoadInfo::GetExternalContentPolicyType; + + void SetIsPreflight(); + void SetUpgradeInsecureRequests(bool aValue); + void SetBrowserUpgradeInsecureRequests(); + void SetBrowserWouldUpgradeInsecureRequests(); + void SetIsFromProcessingFrameAttributes(); + + // Hands off from the cspToInherit functionality! + // + // For navigations, GetCSPToInherit returns what the spec calls the + // "request's client's global object's CSP list", or more precisely + // a snapshot of it taken when the navigation starts. For navigations + // that need to inherit their CSP, this is the right CSP to use for + // the new document. We need a way to transfer the CSP from the + // docshell (where the navigation starts) to the point where the new + // document is created and decides whether to inherit its CSP, and + // this is the mechanism we use for that. + // + // For example: + // A document with a CSP triggers a new top-level data: URI load. + // We pass the CSP of the document that triggered the load all the + // way to docshell. Within docshell we call SetCSPToInherit() on the + // loadinfo. Within Document::InitCSP() we check if the newly created + // document needs to inherit the CSP. If so, we call GetCSPToInherit() + // and set the inherited CSP as the CSP for the new document. Please + // note that any additonal Meta CSP in that document will be merged + // into that CSP. Any subresource loads within that document + // subesquently will receive the correct CSP by querying + // loadinfo->GetCSP() from that point on. + void SetCSPToInherit(nsIContentSecurityPolicy* aCspToInherit) { + mCspToInherit = aCspToInherit; + } + + private: + // private constructor that is only allowed to be called from within + // HttpChannelParent and FTPChannelParent declared as friends undeneath. + // In e10s we can not serialize nsINode, hence we store the innerWindowID. + // Please note that aRedirectChain uses swapElements. + LoadInfo( + nsIPrincipal* aLoadingPrincipal, nsIPrincipal* aTriggeringPrincipal, + nsIPrincipal* aPrincipalToInherit, + nsIPrincipal* aSandboxedLoadingPrincipal, + nsIPrincipal* aTopLevelPrincipal, + nsIPrincipal* aTopLevelStorageAreaPrincipal, nsIURI* aResultPrincipalURI, + nsICookieJarSettings* aCookieJarSettings, + nsIContentSecurityPolicy* aCspToInherit, + const Maybe<mozilla::dom::ClientInfo>& aClientInfo, + const Maybe<mozilla::dom::ClientInfo>& aReservedClientInfo, + const Maybe<mozilla::dom::ClientInfo>& aInitialClientInfo, + const Maybe<mozilla::dom::ServiceWorkerDescriptor>& aController, + nsSecurityFlags aSecurityFlags, uint32_t aSandboxFlags, + uint32_t aTriggeringSandboxFlags, nsContentPolicyType aContentPolicyType, + LoadTainting aTainting, bool aBlockAllMixedContent, + bool aUpgradeInsecureRequests, bool aBrowserUpgradeInsecureRequests, + bool aBrowserDidUpgradeInsecureRequests, + bool aBrowserWouldUpgradeInsecureRequests, bool aForceAllowDataURI, + bool aAllowInsecureRedirectToDataURI, bool aBypassCORSChecks, + bool aSkipContentPolicyCheckForWebRequest, bool aOriginalFrameSrcLoad, + bool aForceInheritPrincipalDropped, uint64_t aInnerWindowID, + uint64_t aBrowsingContextID, uint64_t aFrameBrowsingContextID, + bool aInitialSecurityCheckDone, bool aIsThirdPartyContext, + bool aIsThirdPartyContextToTopWindow, bool aIsFormSubmission, + bool aSendCSPViolationEvents, const OriginAttributes& aOriginAttributes, + RedirectHistoryArray&& aRedirectChainIncludingInternalRedirects, + RedirectHistoryArray&& aRedirectChain, + nsTArray<nsCOMPtr<nsIPrincipal>>&& aAncestorPrincipals, + const nsTArray<uint64_t>& aAncestorBrowsingContextIDs, + const nsTArray<nsCString>& aCorsUnsafeHeaders, bool aForcePreflight, + bool aIsPreflight, bool aLoadTriggeredFromExternal, + bool aServiceWorkerTaintingSynthesized, bool aDocumentHasUserInteracted, + bool aAllowListFutureDocumentsCreatedFromThisRedirectChain, + const nsAString& aCspNonce, bool aSkipContentSniffing, + uint32_t aHttpsOnlyStatus, bool aHasValidUserGestureActivation, + bool aAllowDeprecatedSystemRequests, bool aIsInDevToolsContext, + bool aParserCreatedScript, bool aHasStoragePermission, + uint32_t aRequestBlockingReason, nsINode* aLoadingContext, + nsILoadInfo::CrossOriginEmbedderPolicy aLoadingEmbedderPolicy); + LoadInfo(const LoadInfo& rhs); + + NS_IMETHOD GetRedirects(JSContext* aCx, + JS::MutableHandle<JS::Value> aRedirects, + const RedirectHistoryArray& aArra); + + friend nsresult mozilla::ipc::LoadInfoArgsToLoadInfo( + const Maybe<mozilla::net::LoadInfoArgs>& aLoadInfoArgs, + nsINode* aCspToInheritLoadingContext, net::LoadInfo** outLoadInfo); + + ~LoadInfo() = default; + + void ComputeIsThirdPartyContext(nsPIDOMWindowOuter* aOuterWindow); + void ComputeIsThirdPartyContext(dom::WindowGlobalParent* aGlobal); + + // This function is the *only* function which can change the securityflags + // of a loadinfo. It only exists because of the XHR code. Don't call it + // from anywhere else! + void SetIncludeCookiesSecFlag(); + friend class mozilla::dom::XMLHttpRequestMainThread; + + // nsDocShell::OpenInitializedChannel needs to update the loadInfo with + // the correct browsingContext. + friend class ::nsDocShell; + void UpdateBrowsingContextID(uint64_t aBrowsingContextID) { + mBrowsingContextID = aBrowsingContextID; + } + void UpdateFrameBrowsingContextID(uint64_t aFrameBrowsingContextID) { + mFrameBrowsingContextID = aFrameBrowsingContextID; + } + + // if you add a member, please also update the copy constructor and consider + // if it should be merged from parent channel through + // ParentLoadInfoForwarderArgs. + nsCOMPtr<nsIPrincipal> mLoadingPrincipal; + nsCOMPtr<nsIPrincipal> mTriggeringPrincipal; + nsCOMPtr<nsIPrincipal> mPrincipalToInherit; + nsCOMPtr<nsIPrincipal> mSandboxedLoadingPrincipal; + nsCOMPtr<nsIPrincipal> mTopLevelPrincipal; + nsCOMPtr<nsIPrincipal> mTopLevelStorageAreaPrincipal; + nsCOMPtr<nsIURI> mResultPrincipalURI; + nsCOMPtr<nsICSPEventListener> mCSPEventListener; + nsCOMPtr<nsICookieJarSettings> mCookieJarSettings; + nsCOMPtr<nsIContentSecurityPolicy> mCspToInherit; + + Maybe<mozilla::dom::ClientInfo> mClientInfo; + UniquePtr<mozilla::dom::ClientSource> mReservedClientSource; + Maybe<mozilla::dom::ClientInfo> mReservedClientInfo; + Maybe<mozilla::dom::ClientInfo> mInitialClientInfo; + Maybe<mozilla::dom::ServiceWorkerDescriptor> mController; + RefPtr<mozilla::dom::PerformanceStorage> mPerformanceStorage; + + nsWeakPtr mLoadingContext; + nsWeakPtr mContextForTopLevelLoad; + nsSecurityFlags mSecurityFlags; + uint32_t mSandboxFlags; + uint32_t mTriggeringSandboxFlags; + nsContentPolicyType mInternalContentPolicyType; + LoadTainting mTainting = LoadTainting::Basic; + bool mBlockAllMixedContent = false; + bool mUpgradeInsecureRequests = false; + bool mBrowserUpgradeInsecureRequests = false; + bool mBrowserDidUpgradeInsecureRequests = false; + bool mBrowserWouldUpgradeInsecureRequests = false; + bool mForceAllowDataURI = false; + bool mAllowInsecureRedirectToDataURI = false; + bool mBypassCORSChecks = false; + bool mSkipContentPolicyCheckForWebRequest = false; + bool mOriginalFrameSrcLoad = false; + bool mForceInheritPrincipalDropped = false; + uint64_t mInnerWindowID = 0; + uint64_t mBrowsingContextID = 0; + uint64_t mFrameBrowsingContextID = 0; + bool mInitialSecurityCheckDone = false; + // NB: TYPE_DOCUMENT implies !third-party. + bool mIsThirdPartyContext = false; + bool mIsThirdPartyContextToTopWindow = true; + bool mIsFormSubmission = false; + bool mSendCSPViolationEvents = true; + OriginAttributes mOriginAttributes; + RedirectHistoryArray mRedirectChainIncludingInternalRedirects; + RedirectHistoryArray mRedirectChain; + nsTArray<nsCOMPtr<nsIPrincipal>> mAncestorPrincipals; + nsTArray<uint64_t> mAncestorBrowsingContextIDs; + nsTArray<nsCString> mCorsUnsafeHeaders; + uint32_t mRequestBlockingReason = BLOCKING_REASON_NONE; + bool mForcePreflight = false; + bool mIsPreflight = false; + bool mLoadTriggeredFromExternal = false; + bool mServiceWorkerTaintingSynthesized = false; + bool mDocumentHasUserInteracted = false; + bool mAllowListFutureDocumentsCreatedFromThisRedirectChain = false; + nsString mCspNonce; + bool mSkipContentSniffing = false; + uint32_t mHttpsOnlyStatus = nsILoadInfo::HTTPS_ONLY_UNINITIALIZED; + bool mHasValidUserGestureActivation = false; + bool mAllowDeprecatedSystemRequests = false; + bool mIsInDevToolsContext = false; + bool mParserCreatedScript = false; + bool mHasStoragePermission = false; + + // Is true if this load was triggered by processing the attributes of the + // browsing context container. + // See nsILoadInfo.isFromProcessingFrameAttributes + bool mIsFromProcessingFrameAttributes = false; + + // The cross origin embedder policy that the loading need to respect. + // If the value is nsILoadInfo::EMBEDDER_POLICY_REQUIRE_CORP, CORP checking + // must be performed for the loading. + // See https://wicg.github.io/cross-origin-embedder-policy/#corp-check. + nsILoadInfo::CrossOriginEmbedderPolicy mLoadingEmbedderPolicy = + nsILoadInfo::EMBEDDER_POLICY_NULL; +}; + +} // namespace net +} // namespace mozilla + +#endif // mozilla_LoadInfo_h diff --git a/netwerk/base/LoadTainting.h b/netwerk/base/LoadTainting.h new file mode 100644 index 0000000000..e01d5cd6a3 --- /dev/null +++ b/netwerk/base/LoadTainting.h @@ -0,0 +1,38 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +#ifndef mozilla_LoadTainting_h +#define mozilla_LoadTainting_h + +namespace mozilla { + +// Define an enumeration to reflect the concept of response tainting from the +// the fetch spec: +// +// https://fetch.spec.whatwg.org/#concept-request-response-tainting +// +// Roughly the tainting means: +// +// * Basic: the request resulted in a same-origin or non-http load +// * CORS: the request resulted in a cross-origin load with CORS headers +// * Opaque: the request resulted in a cross-origin load without CORS headers +// +// The enumeration is purposefully designed such that more restrictive tainting +// corresponds to a higher integral value. +// +// NOTE: Checking the tainting is not currently adequate. You *must* still +// check the final URL and CORS mode on the channel. +// +// These values are currently only set on the channel LoadInfo when the request +// was initiated through fetch() or when a service worker interception occurs. +// In the future we should set the tainting value within necko so that it is +// consistently applied. Once that is done consumers can replace checks against +// the final URL and CORS mode with checks against tainting. +enum class LoadTainting : uint8_t { Basic = 0, CORS = 1, Opaque = 2 }; + +} // namespace mozilla + +#endif // mozilla_LoadTainting_h diff --git a/netwerk/base/MemoryDownloader.cpp b/netwerk/base/MemoryDownloader.cpp new file mode 100644 index 0000000000..1ff1c9d1e3 --- /dev/null +++ b/netwerk/base/MemoryDownloader.cpp @@ -0,0 +1,72 @@ +/* -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "MemoryDownloader.h" + +#include "mozilla/Assertions.h" +#include "nsIInputStream.h" + +namespace mozilla { +namespace net { + +NS_IMPL_ISUPPORTS(MemoryDownloader, nsIStreamListener, nsIRequestObserver) + +MemoryDownloader::MemoryDownloader(IObserver* aObserver) + : mObserver(aObserver), mStatus(NS_ERROR_NOT_INITIALIZED) {} + +NS_IMETHODIMP +MemoryDownloader::OnStartRequest(nsIRequest* aRequest) { + MOZ_ASSERT(!mData); + mData.reset(new FallibleTArray<uint8_t>()); + mStatus = NS_OK; + return NS_OK; +} + +NS_IMETHODIMP +MemoryDownloader::OnStopRequest(nsIRequest* aRequest, nsresult aStatus) { + MOZ_ASSERT_IF(NS_FAILED(mStatus), NS_FAILED(aStatus)); + MOZ_ASSERT(!mData == NS_FAILED(mStatus)); + Data data; + data.swap(mData); + RefPtr<IObserver> observer; + observer.swap(mObserver); + observer->OnDownloadComplete(this, aRequest, nullptr, aStatus, + std::move(data)); + return NS_OK; +} + +nsresult MemoryDownloader::ConsumeData(nsIInputStream* aIn, void* aClosure, + const char* aFromRawSegment, + uint32_t aToOffset, uint32_t aCount, + uint32_t* aWriteCount) { + MemoryDownloader* self = static_cast<MemoryDownloader*>(aClosure); + if (!self->mData->AppendElements(aFromRawSegment, aCount, fallible)) { + // The error returned by ConsumeData isn't propagated to the + // return of ReadSegments, so it has to be passed as state. + self->mStatus = NS_ERROR_OUT_OF_MEMORY; + return NS_ERROR_OUT_OF_MEMORY; + } + *aWriteCount = aCount; + return NS_OK; +} + +NS_IMETHODIMP +MemoryDownloader::OnDataAvailable(nsIRequest* aRequest, nsIInputStream* aInStr, + uint64_t aSourceOffset, uint32_t aCount) { + uint32_t n; + MOZ_ASSERT(mData); + nsresult rv = aInStr->ReadSegments(ConsumeData, this, aCount, &n); + if (NS_SUCCEEDED(mStatus) && NS_FAILED(rv)) { + mStatus = rv; + } + if (NS_WARN_IF(NS_FAILED(mStatus))) { + mData.reset(nullptr); + return mStatus; + } + return NS_OK; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/MemoryDownloader.h b/netwerk/base/MemoryDownloader.h new file mode 100644 index 0000000000..6337d439ea --- /dev/null +++ b/netwerk/base/MemoryDownloader.h @@ -0,0 +1,59 @@ +/* -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef mozilla_net_MemoryDownloader_h__ +#define mozilla_net_MemoryDownloader_h__ + +#include "mozilla/UniquePtr.h" +#include "nsCOMPtr.h" +#include "nsIStreamListener.h" +#include "nsTArray.h" + +/** + * mozilla::net::MemoryDownloader + * + * This class is similar to nsIDownloader, but stores the downloaded + * stream in memory instead of a file. Ownership of the temporary + * memory is transferred to the observer when download is complete; + * there is no need to retain a reference to the downloader. + */ + +namespace mozilla { +namespace net { + +class MemoryDownloader final : public nsIStreamListener { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIREQUESTOBSERVER + NS_DECL_NSISTREAMLISTENER + + typedef mozilla::UniquePtr<FallibleTArray<uint8_t>> Data; + + class IObserver : public nsISupports { + public: + // Note: aData may be null if (and only if) aStatus indicates failure. + virtual void OnDownloadComplete(MemoryDownloader* aDownloader, + nsIRequest* aRequest, nsISupports* aCtxt, + nsresult aStatus, Data aData) = 0; + }; + + explicit MemoryDownloader(IObserver* aObserver); + + private: + virtual ~MemoryDownloader() = default; + + static nsresult ConsumeData(nsIInputStream* in, void* closure, + const char* fromRawSegment, uint32_t toOffset, + uint32_t count, uint32_t* writeCount); + + RefPtr<IObserver> mObserver; + Data mData; + nsresult mStatus; +}; + +} // namespace net +} // namespace mozilla + +#endif // mozilla_net_MemoryDownloader_h__ diff --git a/netwerk/base/NetUtil.jsm b/netwerk/base/NetUtil.jsm new file mode 100644 index 0000000000..f901b9805b --- /dev/null +++ b/netwerk/base/NetUtil.jsm @@ -0,0 +1,453 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 4 -*- + * vim: sw=4 ts=4 sts=4 et filetype=javascript + * 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/. */ + +var EXPORTED_SYMBOLS = ["NetUtil"]; + +/** + * Necko utilities + */ + +// ////////////////////////////////////////////////////////////////////////////// +// // Constants + +const PR_UINT32_MAX = 0xffffffff; + +const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm"); + +const BinaryInputStream = Components.Constructor( + "@mozilla.org/binaryinputstream;1", + "nsIBinaryInputStream", + "setInputStream" +); + +// ////////////////////////////////////////////////////////////////////////////// +// // NetUtil Object + +var NetUtil = { + /** + * Function to perform simple async copying from aSource (an input stream) + * to aSink (an output stream). The copy will happen on some background + * thread. Both streams will be closed when the copy completes. + * + * @param aSource + * The input stream to read from + * @param aSink + * The output stream to write to + * @param aCallback [optional] + * A function that will be called at copy completion with a single + * argument: the nsresult status code for the copy operation. + * + * @return An nsIRequest representing the copy operation (for example, this + * can be used to cancel the copying). The consumer can ignore the + * return value if desired. + */ + asyncCopy: function NetUtil_asyncCopy(aSource, aSink, aCallback = null) { + if (!aSource || !aSink) { + let exception = new Components.Exception( + "Must have a source and a sink", + Cr.NS_ERROR_INVALID_ARG, + Components.stack.caller + ); + throw exception; + } + + // make a stream copier + var copier = Cc[ + "@mozilla.org/network/async-stream-copier;1" + ].createInstance(Ci.nsIAsyncStreamCopier2); + copier.init( + aSource, + aSink, + null /* Default event target */, + 0 /* Default length */, + true, + true /* Auto-close */ + ); + + var observer; + if (aCallback) { + observer = { + onStartRequest(aRequest) {}, + onStopRequest(aRequest, aStatusCode) { + aCallback(aStatusCode); + }, + }; + } else { + observer = null; + } + + // start the copying + copier.QueryInterface(Ci.nsIAsyncStreamCopier).asyncCopy(observer, null); + return copier; + }, + + /** + * Asynchronously opens a source and fetches the response. While the fetch + * is asynchronous, I/O may happen on the main thread. When reading from + * a local file, prefer using "OS.File" methods instead. + * + * @param aSource + * This argument can be one of the following: + * - An options object that will be passed to NetUtil.newChannel. + * - An existing nsIChannel. + * - An existing nsIInputStream. + * Using an nsIURI, nsIFile, or string spec directly is deprecated. + * @param aCallback + * The callback function that will be notified upon completion. It + * will get these arguments: + * 1) An nsIInputStream containing the data from aSource, if any. + * 2) The status code from opening the source. + * 3) Reference to the nsIRequest. + */ + asyncFetch: function NetUtil_asyncFetch(aSource, aCallback) { + if (!aSource || !aCallback) { + let exception = new Components.Exception( + "Must have a source and a callback", + Cr.NS_ERROR_INVALID_ARG, + Components.stack.caller + ); + throw exception; + } + + // Create a pipe that will create our output stream that we can use once + // we have gotten all the data. + let pipe = Cc["@mozilla.org/pipe;1"].createInstance(Ci.nsIPipe); + pipe.init(true, true, 0, PR_UINT32_MAX, null); + + // Create a listener that will give data to the pipe's output stream. + let listener = Cc[ + "@mozilla.org/network/simple-stream-listener;1" + ].createInstance(Ci.nsISimpleStreamListener); + listener.init(pipe.outputStream, { + onStartRequest(aRequest) {}, + onStopRequest(aRequest, aStatusCode) { + pipe.outputStream.close(); + aCallback(pipe.inputStream, aStatusCode, aRequest); + }, + }); + + // Input streams are handled slightly differently from everything else. + if (aSource instanceof Ci.nsIInputStream) { + let pump = Cc["@mozilla.org/network/input-stream-pump;1"].createInstance( + Ci.nsIInputStreamPump + ); + pump.init(aSource, 0, 0, true); + pump.asyncRead(listener, null); + return; + } + + let channel = aSource; + if (!(channel instanceof Ci.nsIChannel)) { + channel = this.newChannel(aSource); + } + + try { + channel.asyncOpen(listener); + } catch (e) { + let exception = new Components.Exception( + "Failed to open input source '" + channel.originalURI.spec + "'", + e.result, + Components.stack.caller, + aSource, + e + ); + throw exception; + } + }, + + /** + * Constructs a new URI for the given spec, character set, and base URI, or + * an nsIFile. + * + * @param aTarget + * The string spec for the desired URI or an nsIFile. + * @param aOriginCharset [optional] + * The character set for the URI. Only used if aTarget is not an + * nsIFile. + * @param aBaseURI [optional] + * The base URI for the spec. Only used if aTarget is not an + * nsIFile. + * + * @return an nsIURI object. + */ + newURI: function NetUtil_newURI(aTarget, aOriginCharset, aBaseURI) { + if (!aTarget) { + let exception = new Components.Exception( + "Must have a non-null string spec or nsIFile object", + Cr.NS_ERROR_INVALID_ARG, + Components.stack.caller + ); + throw exception; + } + + if (aTarget instanceof Ci.nsIFile) { + return Services.io.newFileURI(aTarget); + } + + return Services.io.newURI(aTarget, aOriginCharset, aBaseURI); + }, + + /** + * Constructs a new channel for the given source. + * + * Keep in mind that URIs coming from a webpage should *never* use the + * systemPrincipal as the loadingPrincipal. + * + * @param aWhatToLoad + * This argument used to be a string spec for the desired URI, an + * nsIURI, or an nsIFile. Now it should be an options object with + * the following properties: + * { + * uri: + * The full URI spec string, nsIURI or nsIFile to create the + * channel for. + * Note that this cannot be an nsIFile if you have to specify a + * non-default charset or base URI. Call NetUtil.newURI first if + * you need to construct an URI using those options. + * loadingNode: + * loadingPrincipal: + * triggeringPrincipal: + * securityFlags: + * contentPolicyType: + * These will be used as values for the nsILoadInfo object on the + * created channel. For details, see nsILoadInfo in nsILoadInfo.idl + * loadUsingSystemPrincipal: + * Set this to true to use the system principal as + * loadingPrincipal. This must be omitted if loadingPrincipal or + * loadingNode are present. + * This should be used with care as it skips security checks. + * } + * @return an nsIChannel object. + */ + newChannel: function NetUtil_newChannel(aWhatToLoad) { + // Make sure the API is called using only the options object. + if (typeof aWhatToLoad != "object" || arguments.length != 1) { + throw new Components.Exception( + "newChannel requires a single object argument", + Cr.NS_ERROR_INVALID_ARG, + Components.stack.caller + ); + } + + let { + uri, + loadingNode, + loadingPrincipal, + loadUsingSystemPrincipal, + triggeringPrincipal, + securityFlags, + contentPolicyType, + } = aWhatToLoad; + + if (!uri) { + throw new Components.Exception( + "newChannel requires the 'uri' property on the options object.", + Cr.NS_ERROR_INVALID_ARG, + Components.stack.caller + ); + } + + if (typeof uri == "string" || uri instanceof Ci.nsIFile) { + uri = this.newURI(uri); + } + + if (!loadingNode && !loadingPrincipal && !loadUsingSystemPrincipal) { + throw new Components.Exception( + "newChannel requires at least one of the 'loadingNode'," + + " 'loadingPrincipal', or 'loadUsingSystemPrincipal'" + + " properties on the options object.", + Cr.NS_ERROR_INVALID_ARG, + Components.stack.caller + ); + } + + if (loadUsingSystemPrincipal === true) { + if (loadingNode || loadingPrincipal) { + throw new Components.Exception( + "newChannel does not accept 'loadUsingSystemPrincipal'" + + " if the 'loadingNode' or 'loadingPrincipal' properties" + + " are present on the options object.", + Cr.NS_ERROR_INVALID_ARG, + Components.stack.caller + ); + } + loadingPrincipal = Services.scriptSecurityManager.getSystemPrincipal(); + } else if (loadUsingSystemPrincipal !== undefined) { + throw new Components.Exception( + "newChannel requires the 'loadUsingSystemPrincipal'" + + " property on the options object to be 'true' or 'undefined'.", + Cr.NS_ERROR_INVALID_ARG, + Components.stack.caller + ); + } + + if (securityFlags === undefined) { + if (!loadUsingSystemPrincipal) { + throw new Components.Exception( + "newChannel requires the 'securityFlags' property on" + + " the options object unless loading from system principal.", + Cr.NS_ERROR_INVALID_ARG, + Components.stack.caller + ); + } + securityFlags = Ci.nsILoadInfo.SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL; + } + + if (contentPolicyType === undefined) { + if (!loadUsingSystemPrincipal) { + throw new Components.Exception( + "newChannel requires the 'contentPolicyType' property on" + + " the options object unless loading from system principal.", + Cr.NS_ERROR_INVALID_ARG, + Components.stack.caller + ); + } + contentPolicyType = Ci.nsIContentPolicy.TYPE_OTHER; + } + + let channel = Services.io.newChannelFromURI( + uri, + loadingNode || null, + loadingPrincipal || null, + triggeringPrincipal || null, + securityFlags, + contentPolicyType + ); + if (loadUsingSystemPrincipal) { + channel.loadInfo.allowDeprecatedSystemRequests = true; + } + return channel; + }, + + /** + * Reads aCount bytes from aInputStream into a string. + * + * @param aInputStream + * The input stream to read from. + * @param aCount + * The number of bytes to read from the stream. + * @param aOptions [optional] + * charset + * The character encoding of stream data. + * replacement + * The character to replace unknown byte sequences. + * If unset, it causes an exceptions to be thrown. + * + * @return the bytes from the input stream in string form. + * + * @throws NS_ERROR_INVALID_ARG if aInputStream is not an nsIInputStream. + * @throws NS_BASE_STREAM_WOULD_BLOCK if reading from aInputStream would + * block the calling thread (non-blocking mode only). + * @throws NS_ERROR_FAILURE if there are not enough bytes available to read + * aCount amount of data. + * @throws NS_ERROR_ILLEGAL_INPUT if aInputStream has invalid sequences + */ + readInputStreamToString: function NetUtil_readInputStreamToString( + aInputStream, + aCount, + aOptions + ) { + if (!(aInputStream instanceof Ci.nsIInputStream)) { + let exception = new Components.Exception( + "First argument should be an nsIInputStream", + Cr.NS_ERROR_INVALID_ARG, + Components.stack.caller + ); + throw exception; + } + + if (!aCount) { + let exception = new Components.Exception( + "Non-zero amount of bytes must be specified", + Cr.NS_ERROR_INVALID_ARG, + Components.stack.caller + ); + throw exception; + } + + if (aOptions && "charset" in aOptions) { + let cis = Cc["@mozilla.org/intl/converter-input-stream;1"].createInstance( + Ci.nsIConverterInputStream + ); + try { + // When replacement is set, the character that is unknown sequence + // replaces with aOptions.replacement character. + if (!("replacement" in aOptions)) { + // aOptions.replacement isn't set. + // If input stream has unknown sequences for aOptions.charset, + // throw NS_ERROR_ILLEGAL_INPUT. + aOptions.replacement = 0; + } + + cis.init(aInputStream, aOptions.charset, aCount, aOptions.replacement); + let str = {}; + cis.readString(-1, str); + cis.close(); + return str.value; + } catch (e) { + // Adjust the stack so it throws at the caller's location. + throw new Components.Exception( + e.message, + e.result, + Components.stack.caller, + e.data + ); + } + } + + let sis = Cc["@mozilla.org/scriptableinputstream;1"].createInstance( + Ci.nsIScriptableInputStream + ); + sis.init(aInputStream); + try { + return sis.readBytes(aCount); + } catch (e) { + // Adjust the stack so it throws at the caller's location. + throw new Components.Exception( + e.message, + e.result, + Components.stack.caller, + e.data + ); + } + }, + + /** + * Reads aCount bytes from aInputStream into a string. + * + * @param {nsIInputStream} aInputStream + * The input stream to read from. + * @param {integer} [aCount = aInputStream.available()] + * The number of bytes to read from the stream. + * + * @return the bytes from the input stream in string form. + * + * @throws NS_ERROR_INVALID_ARG if aInputStream is not an nsIInputStream. + * @throws NS_BASE_STREAM_WOULD_BLOCK if reading from aInputStream would + * block the calling thread (non-blocking mode only). + * @throws NS_ERROR_FAILURE if there are not enough bytes available to read + * aCount amount of data. + */ + readInputStream(aInputStream, aCount) { + if (!(aInputStream instanceof Ci.nsIInputStream)) { + let exception = new Components.Exception( + "First argument should be an nsIInputStream", + Cr.NS_ERROR_INVALID_ARG, + Components.stack.caller + ); + throw exception; + } + + if (!aCount) { + aCount = aInputStream.available(); + } + + let stream = new BinaryInputStream(aInputStream); + let result = new ArrayBuffer(aCount); + stream.readArrayBuffer(result.byteLength, result); + return result; + }, +}; diff --git a/netwerk/base/NetworkConnectivityService.cpp b/netwerk/base/NetworkConnectivityService.cpp new file mode 100644 index 0000000000..4e92cb4d69 --- /dev/null +++ b/netwerk/base/NetworkConnectivityService.cpp @@ -0,0 +1,526 @@ +/* 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 "NetworkConnectivityService.h" +#include "mozilla/Preferences.h" +#include "mozilla/Services.h" +#include "xpcpublic.h" +#include "nsSocketTransport2.h" +#include "nsIHttpChannelInternal.h" +#include "nsINetworkLinkService.h" +#include "mozilla/StaticPrefs_network.h" + +static LazyLogModule gNCSLog("NetworkConnectivityService"); +#undef LOG +#define LOG(args) MOZ_LOG(gNCSLog, mozilla::LogLevel::Debug, args) + +namespace mozilla { +namespace net { + +NS_IMPL_ISUPPORTS(NetworkConnectivityService, nsIDNSListener, nsIObserver, + nsINetworkConnectivityService, nsIStreamListener) + +static StaticRefPtr<NetworkConnectivityService> gConnService; + +NetworkConnectivityService::NetworkConnectivityService() + : mNAT64(UNKNOWN), mLock("nat64prefixes") {} + +// static +already_AddRefed<NetworkConnectivityService> +NetworkConnectivityService::GetSingleton() { + if (!XRE_IsParentProcess()) { + return nullptr; + } + + if (gConnService) { + return do_AddRef(gConnService); + } + + RefPtr<NetworkConnectivityService> service = new NetworkConnectivityService(); + service->Init(); + + gConnService = std::move(service); + ClearOnShutdown(&gConnService); + return do_AddRef(gConnService); +} + +nsresult NetworkConnectivityService::Init() { + nsCOMPtr<nsIObserverService> observerService = + mozilla::services::GetObserverService(); + observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false); + observerService->AddObserver(this, NS_NETWORK_LINK_TOPIC, false); + observerService->AddObserver(this, "network:captive-portal-connectivity", + false); + + return NS_OK; +} + +NS_IMETHODIMP +NetworkConnectivityService::GetDNSv4(ConnectivityState* aState) { + NS_ENSURE_ARG(aState); + *aState = mDNSv4; + return NS_OK; +} + +NS_IMETHODIMP +NetworkConnectivityService::GetDNSv6(ConnectivityState* aState) { + NS_ENSURE_ARG(aState); + *aState = mDNSv6; + return NS_OK; +} + +NS_IMETHODIMP +NetworkConnectivityService::GetIPv4(ConnectivityState* aState) { + NS_ENSURE_ARG(aState); + *aState = mIPv4; + return NS_OK; +} + +NS_IMETHODIMP +NetworkConnectivityService::GetIPv6(ConnectivityState* aState) { + NS_ENSURE_ARG(aState); + *aState = mIPv6; + return NS_OK; +} + +NS_IMETHODIMP +NetworkConnectivityService::GetNAT64(ConnectivityState* aState) { + NS_ENSURE_ARG(aState); + *aState = mNAT64; + return NS_OK; +} + +already_AddRefed<AddrInfo> NetworkConnectivityService::MapNAT64IPs( + AddrInfo* aNewRRSet) { + // Add prefixes only if there are no IPv6 addresses. + // Expect that if aNewRRSet has IPv6 addresses, they must come + // before IPv4 addresses. + if (aNewRRSet->Addresses().IsEmpty() || + aNewRRSet->Addresses()[0].raw.family == PR_AF_INET6) { + return do_AddRef(aNewRRSet); + } + + // Currently we only add prefixes to the first IP's clones. + uint32_t ip = aNewRRSet->Addresses()[0].inet.ip; + nsTArray<NetAddr> addresses = aNewRRSet->Addresses().Clone(); + + { + MutexAutoLock lock(mLock); + for (const auto& prefix : mNAT64Prefixes) { + NetAddr addr = NetAddr(prefix); + + // Copy the IPv4 address to the end + addr.inet6.ip.u32[3] = ip; + + // If we have both IPv4 and NAT64, we be could insourcing NAT64 + // to avoid double NAT and improve performance. However, this + // breaks WebRTC, so we push it to the back. + addresses.AppendElement(addr); + } + } + + auto builder = aNewRRSet->Build(); + builder.SetAddresses(std::move(addresses)); + return builder.Finish(); +} + +// Returns true if a prefix was read and saved to the argument +static inline bool NAT64PrefixFromPref(NetAddr* prefix) { + nsAutoCString nat64PrefixPref; + PRNetAddr prAddr{}; + + nsresult rv = Preferences::GetCString( + "network.connectivity-service.nat64-prefix", nat64PrefixPref); + if (NS_FAILED(rv) || nat64PrefixPref.IsEmpty() || + PR_StringToNetAddr(nat64PrefixPref.get(), &prAddr) != PR_SUCCESS || + prAddr.raw.family != PR_AF_INET6) { + return false; + } + + PRNetAddrToNetAddr(&prAddr, prefix); + return true; +} + +static inline bool NAT64PrefixCompare(const NetAddr& prefix1, + const NetAddr& prefix2) { + // Compare the first 96 bits as 64 + 32 + return prefix1.inet6.ip.u64[0] == prefix2.inet6.ip.u64[0] && + prefix1.inet6.ip.u32[2] == prefix2.inet6.ip.u32[2]; +} + +void NetworkConnectivityService::PerformChecks() { + mDNSv4 = UNKNOWN; + mDNSv6 = UNKNOWN; + + mIPv4 = UNKNOWN; + mIPv6 = UNKNOWN; + + mNAT64 = UNKNOWN; + + { + MutexAutoLock lock(mLock); + mNAT64Prefixes.Clear(); + + // NAT64 checks might be disabled. + // Since We can't guarantee a DNS response, we should set up + // NAT64 manually now if needed. + + NetAddr priorityPrefix{}; + bool havePrefix = NAT64PrefixFromPref(&priorityPrefix); + if (havePrefix) { + mNAT64Prefixes.AppendElement(priorityPrefix); + mNAT64 = OK; + } + } + + RecheckDNS(); + RecheckIPConnectivity(); +} + +static inline void NotifyObservers(const char* aTopic) { + nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); + obs->NotifyObservers(nullptr, aTopic, nullptr); +} + +void NetworkConnectivityService::SaveNAT64Prefixes(nsIDNSRecord* aRecord) { + nsCOMPtr<nsIDNSAddrRecord> rec = do_QueryInterface(aRecord); + MutexAutoLock lock(mLock); + mNAT64Prefixes.Clear(); + + NetAddr priorityPrefix{}; + bool havePrefix = NAT64PrefixFromPref(&priorityPrefix); + if (havePrefix) { + mNAT64 = OK; + mNAT64Prefixes.AppendElement(priorityPrefix); + } + + if (!rec) { + if (!havePrefix) { + mNAT64 = NOT_AVAILABLE; + } + return; + } + + mNAT64 = UNKNOWN; + NetAddr addr{}; + + // use port 80 as dummy value for NetAddr + while (NS_SUCCEEDED(rec->GetNextAddr(80, &addr))) { + if (addr.raw.family != AF_INET6 || addr.IsIPAddrV4Mapped()) { + // These are not the kind of addresses we are looking for. + continue; + } + + // RFC 7050 does not require the embedded IPv4 to be + // at the end of IPv6. In practice, and as we assume, + // it is always at the end. + // The embedded IP must be 192.0.0.170 or 192.0.0.171 + + // Clear the last bit to compare with the next one. + addr.inet6.ip.u8[15] &= ~(uint32_t)1; + if ((addr.inet6.ip.u8[12] != 192) || (addr.inet6.ip.u8[13] != 0) || + (addr.inet6.ip.u8[14] != 0) || (addr.inet6.ip.u8[15] != 170)) { + continue; + } + + mNAT64Prefixes.AppendElement(addr); + } + + size_t length = mNAT64Prefixes.Length(); + if (length == 0) { + mNAT64 = NOT_AVAILABLE; + return; + } + + // Remove duplicates. Typically a DNS64 resolver sends every + // prefix twice with address with different last bits. We want + // a list of unique prefixes while reordering is not allowed. + // We must not handle the case with an element in-between + // two identical ones, which is never the case for a properly + // configured DNS64 resolver. + + NetAddr prev = mNAT64Prefixes[0]; + + for (size_t i = 1; i < length; i++) { + if (NAT64PrefixCompare(prev, mNAT64Prefixes[i])) { + mNAT64Prefixes.RemoveElementAt(i); + i--; + length--; + } else { + prev = mNAT64Prefixes[i]; + } + } + + // The prioritized address might also appear in the record we received. + + if (havePrefix) { + for (size_t i = 1; i < length; i++) { + if (NAT64PrefixCompare(priorityPrefix, mNAT64Prefixes[i])) { + mNAT64Prefixes.RemoveElementAt(i); + // It wouldn't appear more than once. + break; + } + } + } + + mNAT64 = OK; +} + +NS_IMETHODIMP +NetworkConnectivityService::OnLookupComplete(nsICancelable* aRequest, + nsIDNSRecord* aRecord, + nsresult aStatus) { + ConnectivityState state = aRecord ? OK : NOT_AVAILABLE; + + if (aRequest == mDNSv4Request) { + mDNSv4 = state; + mDNSv4Request = nullptr; + } else if (aRequest == mDNSv6Request) { + mDNSv6 = state; + mDNSv6Request = nullptr; + } else if (aRequest == mNAT64Request) { + mNAT64Request = nullptr; + SaveNAT64Prefixes(aRecord); + } + + if (!mDNSv4Request && !mDNSv6Request && !mNAT64Request) { + NotifyObservers("network:connectivity-service:dns-checks-complete"); + } + return NS_OK; +} + +NS_IMETHODIMP +NetworkConnectivityService::RecheckDNS() { + bool enabled = + Preferences::GetBool("network.connectivity-service.enabled", false); + if (!enabled) { + return NS_OK; + } + + nsresult rv; + nsCOMPtr<nsIDNSService> dns = do_GetService(NS_DNSSERVICE_CONTRACTID); + OriginAttributes attrs; + nsAutoCString host; + Preferences::GetCString("network.connectivity-service.DNSv4.domain", host); + + rv = dns->AsyncResolveNative(host, nsIDNSService::RESOLVE_TYPE_DEFAULT, + nsIDNSService::RESOLVE_DISABLE_IPV6 | + nsIDNSService::RESOLVE_TRR_DISABLED_MODE, + nullptr, this, NS_GetCurrentThread(), attrs, + getter_AddRefs(mDNSv4Request)); + NS_ENSURE_SUCCESS(rv, rv); + + Preferences::GetCString("network.connectivity-service.DNSv6.domain", host); + rv = dns->AsyncResolveNative(host, nsIDNSService::RESOLVE_TYPE_DEFAULT, + nsIDNSService::RESOLVE_DISABLE_IPV4 | + nsIDNSService::RESOLVE_TRR_DISABLED_MODE, + nullptr, this, NS_GetCurrentThread(), attrs, + getter_AddRefs(mDNSv6Request)); + NS_ENSURE_SUCCESS(rv, rv); + + if (StaticPrefs::network_connectivity_service_nat64_check()) { + rv = dns->AsyncResolveNative("ipv4only.arpa"_ns, + nsIDNSService::RESOLVE_TYPE_DEFAULT, + nsIDNSService::RESOLVE_DISABLE_IPV4 | + nsIDNSService::RESOLVE_TRR_DISABLED_MODE, + nullptr, this, NS_GetCurrentThread(), attrs, + getter_AddRefs(mNAT64Request)); + NS_ENSURE_SUCCESS(rv, rv); + } + return rv; +} + +NS_IMETHODIMP +NetworkConnectivityService::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) { + if (!strcmp(aTopic, "network:captive-portal-connectivity")) { + // Captive portal is cleared, so we redo the checks. + PerformChecks(); + } else if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) { + if (mDNSv4Request) { + mDNSv4Request->Cancel(NS_ERROR_ABORT); + mDNSv4Request = nullptr; + } + if (mDNSv6Request) { + mDNSv6Request->Cancel(NS_ERROR_ABORT); + mDNSv6Request = nullptr; + } + if (mNAT64Request) { + mNAT64Request->Cancel(NS_ERROR_ABORT); + mNAT64Request = nullptr; + } + + nsCOMPtr<nsIObserverService> observerService = + mozilla::services::GetObserverService(); + observerService->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID); + observerService->RemoveObserver(this, + "network:captive-portal-connectivity"); + observerService->RemoveObserver(this, NS_NETWORK_LINK_TOPIC); + } else if (!strcmp(aTopic, NS_NETWORK_LINK_TOPIC) && + !NS_LITERAL_STRING_FROM_CSTRING(NS_NETWORK_LINK_DATA_UNKNOWN) + .Equals(aData)) { + PerformChecks(); + } + + return NS_OK; +} + +static inline already_AddRefed<nsIChannel> SetupIPCheckChannel(bool ipv4) { + nsresult rv; + nsAutoCString url; + + if (ipv4) { + rv = Preferences::GetCString("network.connectivity-service.IPv4.url", url); + } else { + rv = Preferences::GetCString("network.connectivity-service.IPv6.url", url); + } + NS_ENSURE_SUCCESS(rv, nullptr); + + nsCOMPtr<nsIURI> uri; + rv = NS_NewURI(getter_AddRefs(uri), url); + NS_ENSURE_SUCCESS(rv, nullptr); + + nsCOMPtr<nsIChannel> channel; + rv = NS_NewChannel( + getter_AddRefs(channel), uri, nsContentUtils::GetSystemPrincipal(), + nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL, + nsIContentPolicy::TYPE_OTHER, + nullptr, // nsICookieJarSettings + nullptr, // aPerformanceStorage + nullptr, // aLoadGroup + nullptr, + nsIRequest::LOAD_BYPASS_CACHE | // don't read from the cache + nsIRequest::INHIBIT_CACHING | // don't write the response to cache + nsIRequest::LOAD_ANONYMOUS); // prevent privacy leaks + NS_ENSURE_SUCCESS(rv, nullptr); + + rv = channel->SetTRRMode(nsIRequest::TRR_DISABLED_MODE); + NS_ENSURE_SUCCESS(rv, nullptr); + + { + // Prevent HTTPS-Only Mode from upgrading the OCSP request. + nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo(); + uint32_t httpsOnlyStatus = loadInfo->GetHttpsOnlyStatus(); + httpsOnlyStatus |= nsILoadInfo::HTTPS_ONLY_EXEMPT; + loadInfo->SetHttpsOnlyStatus(httpsOnlyStatus); + + // allow deprecated HTTP request from SystemPrincipal + loadInfo->SetAllowDeprecatedSystemRequests(true); + } + + nsCOMPtr<nsIHttpChannelInternal> internalChan = do_QueryInterface(channel); + NS_ENSURE_TRUE(internalChan, nullptr); + + if (ipv4) { + internalChan->SetIPv6Disabled(); + } else { + internalChan->SetIPv4Disabled(); + } + + return channel.forget(); +} + +NS_IMETHODIMP +NetworkConnectivityService::RecheckIPConnectivity() { + bool enabled = + Preferences::GetBool("network.connectivity-service.enabled", false); + if (!enabled) { + return NS_OK; + } + + if (xpc::AreNonLocalConnectionsDisabled() && + !Preferences::GetBool("network.captive-portal-service.testMode", false)) { + return NS_OK; + } + + if (mIPv4Channel) { + mIPv4Channel->Cancel(NS_ERROR_ABORT); + mIPv4Channel = nullptr; + } + if (mIPv6Channel) { + mIPv6Channel->Cancel(NS_ERROR_ABORT); + mIPv6Channel = nullptr; + } + + nsresult rv; + mHasNetworkId = false; + mCheckedNetworkId = false; + mIPv4Channel = SetupIPCheckChannel(/* ipv4 = */ true); + if (mIPv4Channel) { + rv = mIPv4Channel->AsyncOpen(this); + NS_ENSURE_SUCCESS(rv, rv); + } + + mIPv6Channel = SetupIPCheckChannel(/* ipv4 = */ false); + if (mIPv6Channel) { + rv = mIPv6Channel->AsyncOpen(this); + NS_ENSURE_SUCCESS(rv, rv); + } + + return NS_OK; +} + +NS_IMETHODIMP +NetworkConnectivityService::OnStartRequest(nsIRequest* aRequest) { + return NS_OK; +} + +NS_IMETHODIMP +NetworkConnectivityService::OnStopRequest(nsIRequest* aRequest, + nsresult aStatusCode) { + if (aStatusCode == NS_ERROR_ABORT) { + return NS_OK; + } + + ConnectivityState status = NS_FAILED(aStatusCode) ? NOT_AVAILABLE : OK; + + if (aRequest == mIPv4Channel) { + mIPv4 = status; + mIPv4Channel = nullptr; + + if (mIPv4 == nsINetworkConnectivityService::OK) { + Telemetry::AccumulateCategorical( + mHasNetworkId ? Telemetry::LABELS_NETWORK_ID_ONLINE::present + : Telemetry::LABELS_NETWORK_ID_ONLINE::absent); + LOG(("mHasNetworkId : %d\n", mHasNetworkId)); + } + } else if (aRequest == mIPv6Channel) { + mIPv6 = status; + mIPv6Channel = nullptr; + } + + if (!mIPv6Channel && !mIPv4Channel) { + NotifyObservers("network:connectivity-service:ip-checks-complete"); + } + + return NS_OK; +} + +NS_IMETHODIMP +NetworkConnectivityService::OnDataAvailable(nsIRequest* aRequest, + nsIInputStream* aInputStream, + uint64_t aOffset, uint32_t aCount) { + nsAutoCString data; + + // We perform this check here, instead of doing it in OnStopRequest in case + // a network down event occurs after the data has arrived but before we fire + // OnStopRequest. That would cause us to report a missing networkID, even + // though it was not empty while receiving data. + if (aRequest == mIPv4Channel && !mCheckedNetworkId) { + nsCOMPtr<nsINetworkLinkService> nls = + do_GetService(NS_NETWORK_LINK_SERVICE_CONTRACTID); + nsAutoCString networkId; + if (nls) { + nls->GetNetworkID(networkId); + } + mHasNetworkId = !networkId.IsEmpty(); + mCheckedNetworkId = true; + } + + Unused << NS_ReadInputStreamToString(aInputStream, data, aCount); + return NS_OK; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/NetworkConnectivityService.h b/netwerk/base/NetworkConnectivityService.h new file mode 100644 index 0000000000..190f67a73f --- /dev/null +++ b/netwerk/base/NetworkConnectivityService.h @@ -0,0 +1,72 @@ +/* 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/. */ + +#ifndef NetworkConnectivityService_h_ +#define NetworkConnectivityService_h_ + +#include "nsINetworkConnectivityService.h" +#include "nsIObserver.h" +#include "nsIDNSListener.h" +#include "nsIStreamListener.h" +#include "mozilla/net/DNS.h" + +namespace mozilla { +namespace net { + +class NetworkConnectivityService : public nsINetworkConnectivityService, + public nsIObserver, + public nsIDNSListener, + public nsIStreamListener { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSINETWORKCONNECTIVITYSERVICE + NS_DECL_NSIOBSERVER + NS_DECL_NSIDNSLISTENER + NS_DECL_NSISTREAMLISTENER + NS_DECL_NSIREQUESTOBSERVER + + already_AddRefed<AddrInfo> MapNAT64IPs(AddrInfo* aNewRRSet); + + static already_AddRefed<NetworkConnectivityService> GetSingleton(); + + private: + NetworkConnectivityService(); + virtual ~NetworkConnectivityService() = default; + + nsresult Init(); + // Calls all the check methods + void PerformChecks(); + + void SaveNAT64Prefixes(nsIDNSRecord* aRecord); + + // Will be set to OK if the DNS request returned in IP of this type, + // NOT_AVAILABLE if that type of resolution is not available + // UNKNOWN if the check wasn't performed + ConnectivityState mDNSv4 = nsINetworkConnectivityService::UNKNOWN; + ConnectivityState mDNSv6 = nsINetworkConnectivityService::UNKNOWN; + + ConnectivityState mIPv4 = nsINetworkConnectivityService::UNKNOWN; + ConnectivityState mIPv6 = nsINetworkConnectivityService::UNKNOWN; + + Atomic<ConnectivityState, Relaxed> mNAT64; + + nsTArray<NetAddr> mNAT64Prefixes; + + nsCOMPtr<nsICancelable> mDNSv4Request; + nsCOMPtr<nsICancelable> mDNSv6Request; + nsCOMPtr<nsICancelable> mNAT64Request; + + nsCOMPtr<nsIChannel> mIPv4Channel; + nsCOMPtr<nsIChannel> mIPv6Channel; + + bool mCheckedNetworkId = false; + bool mHasNetworkId = false; + + Mutex mLock; +}; + +} // namespace net +} // namespace mozilla + +#endif // NetworkConnectivityService_h_ diff --git a/netwerk/base/NetworkDataCountLayer.cpp b/netwerk/base/NetworkDataCountLayer.cpp new file mode 100644 index 0000000000..7b6461b5f8 --- /dev/null +++ b/netwerk/base/NetworkDataCountLayer.cpp @@ -0,0 +1,138 @@ +/* -*- 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 "NetworkDataCountLayer.h" +#include "nsSocketTransportService2.h" +#include "prmem.h" +#include "prio.h" + +namespace mozilla { +namespace net { + +static PRDescIdentity sNetworkDataCountLayerIdentity; +static PRIOMethods sNetworkDataCountLayerMethods; +static PRIOMethods* sNetworkDataCountLayerMethodsPtr = nullptr; + +class NetworkDataCountSecret { + public: + NetworkDataCountSecret() {} + + uint64_t mSentBytes = 0; + uint64_t mReceivedBytes = 0; +}; + +static PRInt32 NetworkDataCountSend(PRFileDesc* fd, const void* buf, + PRInt32 amount, PRIntn flags, + PRIntervalTime timeout) { + MOZ_RELEASE_ASSERT(fd->identity == sNetworkDataCountLayerIdentity); + + NetworkDataCountSecret* secret = + reinterpret_cast<NetworkDataCountSecret*>(fd->secret); + + PRInt32 rv = + (fd->lower->methods->send)(fd->lower, buf, amount, flags, timeout); + if (rv > 0) { + secret->mSentBytes += rv; + } + return rv; +} + +static PRInt32 NetworkDataCountWrite(PRFileDesc* fd, const void* buf, + PRInt32 amount) { + return NetworkDataCountSend(fd, buf, amount, 0, PR_INTERVAL_NO_WAIT); +} + +static PRInt32 NetworkDataCountRecv(PRFileDesc* fd, void* buf, PRInt32 amount, + PRIntn flags, PRIntervalTime timeout) { + MOZ_RELEASE_ASSERT(fd->identity == sNetworkDataCountLayerIdentity); + + NetworkDataCountSecret* secret = + reinterpret_cast<NetworkDataCountSecret*>(fd->secret); + + PRInt32 rv = + (fd->lower->methods->recv)(fd->lower, buf, amount, flags, timeout); + if (rv > 0) { + secret->mReceivedBytes += rv; + } + return rv; +} + +static PRInt32 NetworkDataCountRead(PRFileDesc* fd, void* buf, PRInt32 amount) { + return NetworkDataCountRecv(fd, buf, amount, 0, PR_INTERVAL_NO_WAIT); +} + +static PRStatus NetworkDataCountClose(PRFileDesc* fd) { + if (!fd) { + return PR_FAILURE; + } + + PRFileDesc* layer = PR_PopIOLayer(fd, PR_TOP_IO_LAYER); + + MOZ_RELEASE_ASSERT(layer && layer->identity == sNetworkDataCountLayerIdentity, + "NetworkDataCount Layer not on top of stack"); + + NetworkDataCountSecret* secret = + reinterpret_cast<NetworkDataCountSecret*>(layer->secret); + layer->secret = nullptr; + layer->dtor(layer); + delete secret; + return fd->methods->close(fd); +} + +nsresult AttachNetworkDataCountLayer(PRFileDesc* fd) { + if (!sNetworkDataCountLayerMethodsPtr) { + sNetworkDataCountLayerIdentity = + PR_GetUniqueIdentity("NetworkDataCount Layer"); + sNetworkDataCountLayerMethods = *PR_GetDefaultIOMethods(); + sNetworkDataCountLayerMethods.send = NetworkDataCountSend; + sNetworkDataCountLayerMethods.write = NetworkDataCountWrite; + sNetworkDataCountLayerMethods.recv = NetworkDataCountRecv; + sNetworkDataCountLayerMethods.read = NetworkDataCountRead; + sNetworkDataCountLayerMethods.close = NetworkDataCountClose; + sNetworkDataCountLayerMethodsPtr = &sNetworkDataCountLayerMethods; + } + + PRFileDesc* layer = PR_CreateIOLayerStub(sNetworkDataCountLayerIdentity, + sNetworkDataCountLayerMethodsPtr); + + if (!layer) { + return NS_ERROR_FAILURE; + } + + NetworkDataCountSecret* secret = new NetworkDataCountSecret(); + + layer->secret = reinterpret_cast<PRFilePrivate*>(secret); + + PRStatus status = PR_PushIOLayer(fd, PR_NSPR_IO_LAYER, layer); + + if (status == PR_FAILURE) { + delete secret; + PR_Free(layer); // PR_CreateIOLayerStub() uses PR_Malloc(). + return NS_ERROR_FAILURE; + } + return NS_OK; +} + +void NetworkDataCountSent(PRFileDesc* fd, uint64_t& sentBytes) { + PRFileDesc* ndcFd = PR_GetIdentitiesLayer(fd, sNetworkDataCountLayerIdentity); + MOZ_RELEASE_ASSERT(ndcFd); + + NetworkDataCountSecret* secret = + reinterpret_cast<NetworkDataCountSecret*>(ndcFd->secret); + sentBytes = secret->mSentBytes; +} + +void NetworkDataCountReceived(PRFileDesc* fd, uint64_t& receivedBytes) { + PRFileDesc* ndcFd = PR_GetIdentitiesLayer(fd, sNetworkDataCountLayerIdentity); + MOZ_RELEASE_ASSERT(ndcFd); + + NetworkDataCountSecret* secret = + reinterpret_cast<NetworkDataCountSecret*>(ndcFd->secret); + receivedBytes = secret->mReceivedBytes; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/NetworkDataCountLayer.h b/netwerk/base/NetworkDataCountLayer.h new file mode 100644 index 0000000000..b5c486dad8 --- /dev/null +++ b/netwerk/base/NetworkDataCountLayer.h @@ -0,0 +1,26 @@ +/* -*- 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/. */ + +#ifndef NetworkDataCountLayer_h__ +#define NetworkDataCountLayer_h__ + +#include "prerror.h" + +namespace mozilla { +namespace net { + +nsresult AttachNetworkDataCountLayer(PRFileDesc* fd); + +// Get amount of sent bytes. +void NetworkDataCountSent(PRFileDesc* fd, uint64_t& sentBytes); + +// Get amount of received bytes. +void NetworkDataCountReceived(PRFileDesc* fd, uint64_t& receivedBytes); + +} // namespace net +} // namespace mozilla + +#endif // NetworkDataCountLayer_h__ diff --git a/netwerk/base/NetworkInfoServiceCocoa.cpp b/netwerk/base/NetworkInfoServiceCocoa.cpp new file mode 100644 index 0000000000..702617b046 --- /dev/null +++ b/netwerk/base/NetworkInfoServiceCocoa.cpp @@ -0,0 +1,100 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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 <string.h> +#include <unistd.h> +#include <sys/ioctl.h> +#include <sys/socket.h> +#include <sys/types.h> +#include <net/if.h> +#include <netdb.h> + +#include "mozilla/DebugOnly.h" +#include "mozilla/ScopeExit.h" + +#include "NetworkInfoServiceImpl.h" + +namespace mozilla { +namespace net { + +static nsresult ListInterfaceAddresses(int aFd, const char* aIface, + AddrMapType& aAddrMap); + +nsresult DoListAddresses(AddrMapType& aAddrMap) { + int fd = socket(AF_INET, SOCK_DGRAM, 0); + if (fd < 0) { + return NS_ERROR_FAILURE; + } + + auto autoCloseSocket = MakeScopeExit([&] { close(fd); }); + + struct ifconf ifconf; + /* 16k of space should be enough to list all interfaces. Worst case, if it's + * not then we will error out and fail to list addresses. This should only + * happen on pathological machines with way too many interfaces. + */ + char buf[16384]; + + ifconf.ifc_len = sizeof(buf); + ifconf.ifc_buf = buf; + if (ioctl(fd, SIOCGIFCONF, &ifconf) != 0) { + return NS_ERROR_FAILURE; + } + + struct ifreq* ifreq = ifconf.ifc_req; + int i = 0; + while (i < ifconf.ifc_len) { + size_t len = IFNAMSIZ + ifreq->ifr_addr.sa_len; + + DebugOnly<nsresult> rv = + ListInterfaceAddresses(fd, ifreq->ifr_name, aAddrMap); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "ListInterfaceAddresses failed"); + + ifreq = (struct ifreq*)((char*)ifreq + len); + i += len; + } + + autoCloseSocket.release(); + return NS_OK; +} + +static nsresult ListInterfaceAddresses(int aFd, const char* aInterface, + AddrMapType& aAddrMap) { + struct ifreq ifreq; + memset(&ifreq, 0, sizeof(struct ifreq)); + strncpy(ifreq.ifr_name, aInterface, IFNAMSIZ - 1); + if (ioctl(aFd, SIOCGIFADDR, &ifreq) != 0) { + return NS_ERROR_FAILURE; + } + + char host[128]; + int family; + switch (family = ifreq.ifr_addr.sa_family) { + case AF_INET: + case AF_INET6: + getnameinfo(&ifreq.ifr_addr, sizeof(ifreq.ifr_addr), host, sizeof(host), + nullptr, 0, NI_NUMERICHOST); + break; + case AF_UNSPEC: + return NS_OK; + default: + // Unknown family. + return NS_OK; + } + + nsCString ifaceStr; + ifaceStr.AssignASCII(aInterface); + + nsCString addrStr; + addrStr.AssignASCII(host); + + aAddrMap.Put(ifaceStr, addrStr); + + return NS_OK; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/NetworkInfoServiceImpl.h b/netwerk/base/NetworkInfoServiceImpl.h new file mode 100644 index 0000000000..6f89f33a68 --- /dev/null +++ b/netwerk/base/NetworkInfoServiceImpl.h @@ -0,0 +1,18 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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 "nsString.h" +#include "nsDataHashtable.h" + +namespace mozilla { +namespace net { + +typedef nsDataHashtable<nsCStringHashKey, nsCString> AddrMapType; + +nsresult DoListAddresses(AddrMapType& aAddrMap); + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/NetworkInfoServiceLinux.cpp b/netwerk/base/NetworkInfoServiceLinux.cpp new file mode 100644 index 0000000000..9b42ad6dbd --- /dev/null +++ b/netwerk/base/NetworkInfoServiceLinux.cpp @@ -0,0 +1,96 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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 <string.h> +#include <unistd.h> +#include <sys/ioctl.h> +#include <sys/socket.h> +#include <sys/types.h> +#include <net/if.h> +#include <netdb.h> + +#include "mozilla/DebugOnly.h" +#include "mozilla/ScopeExit.h" + +#include "NetworkInfoServiceImpl.h" + +namespace mozilla::net { + +static nsresult ListInterfaceAddresses(int aFd, const char* aIface, + AddrMapType& aAddrMap); + +nsresult DoListAddresses(AddrMapType& aAddrMap) { + int fd = socket(AF_INET, SOCK_DGRAM, 0); + if (fd < 0) { + return NS_ERROR_FAILURE; + } + + auto autoCloseSocket = MakeScopeExit([&] { close(fd); }); + + struct ifconf ifconf; + /* 16k of space should be enough to list all interfaces. Worst case, if it's + * not then we will error out and fail to list addresses. This should only + * happen on pathological machines with way too many interfaces. + */ + char buf[16384]; + + ifconf.ifc_len = sizeof(buf); + ifconf.ifc_buf = buf; + if (ioctl(fd, SIOCGIFCONF, &ifconf) != 0) { + return NS_ERROR_FAILURE; + } + + struct ifreq* ifreq = ifconf.ifc_req; + int i = 0; + while (i < ifconf.ifc_len) { + size_t len = sizeof(struct ifreq); + + DebugOnly<nsresult> rv = + ListInterfaceAddresses(fd, ifreq->ifr_name, aAddrMap); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "ListInterfaceAddresses failed"); + + ifreq = (struct ifreq*)((char*)ifreq + len); + i += len; + } + + return NS_OK; +} + +static nsresult ListInterfaceAddresses(int aFd, const char* aInterface, + AddrMapType& aAddrMap) { + struct ifreq ifreq; + memset(&ifreq, 0, sizeof(struct ifreq)); + strncpy(ifreq.ifr_name, aInterface, IFNAMSIZ - 1); + if (ioctl(aFd, SIOCGIFADDR, &ifreq) != 0) { + return NS_ERROR_FAILURE; + } + + char host[128]; + switch (ifreq.ifr_addr.sa_family) { + case AF_INET: + case AF_INET6: + getnameinfo(&ifreq.ifr_addr, sizeof(ifreq.ifr_addr), host, sizeof(host), + nullptr, 0, NI_NUMERICHOST); + break; + case AF_UNSPEC: + return NS_OK; + default: + // Unknown family. + return NS_OK; + } + + nsCString ifaceStr; + ifaceStr.AssignASCII(aInterface); + + nsCString addrStr; + addrStr.AssignASCII(host); + + aAddrMap.Put(ifaceStr, addrStr); + + return NS_OK; +} + +} // namespace mozilla::net diff --git a/netwerk/base/NetworkInfoServiceWindows.cpp b/netwerk/base/NetworkInfoServiceWindows.cpp new file mode 100644 index 0000000000..c67dd70801 --- /dev/null +++ b/netwerk/base/NetworkInfoServiceWindows.cpp @@ -0,0 +1,58 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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 <winsock2.h> +#include <ws2ipdef.h> +#include <iphlpapi.h> + +#include "mozilla/UniquePtr.h" + +#include "NetworkInfoServiceImpl.h" + +namespace mozilla { +namespace net { + +nsresult DoListAddresses(AddrMapType& aAddrMap) { + UniquePtr<MIB_IPADDRTABLE> ipAddrTable; + DWORD size = sizeof(MIB_IPADDRTABLE); + + ipAddrTable.reset((MIB_IPADDRTABLE*)malloc(size)); + if (!ipAddrTable) { + return NS_ERROR_FAILURE; + } + + DWORD retVal = GetIpAddrTable(ipAddrTable.get(), &size, 0); + if (retVal == ERROR_INSUFFICIENT_BUFFER) { + ipAddrTable.reset((MIB_IPADDRTABLE*)malloc(size)); + if (!ipAddrTable) { + return NS_ERROR_FAILURE; + } + retVal = GetIpAddrTable(ipAddrTable.get(), &size, 0); + } + if (retVal != NO_ERROR) { + return NS_ERROR_FAILURE; + } + + for (DWORD i = 0; i < ipAddrTable->dwNumEntries; i++) { + int index = ipAddrTable->table[i].dwIndex; + uint32_t addrVal = (uint32_t)ipAddrTable->table[i].dwAddr; + + nsCString indexString; + indexString.AppendInt(index, 10); + + nsCString addrString; + addrString.AppendPrintf("%d.%d.%d.%d", (addrVal >> 0) & 0xff, + (addrVal >> 8) & 0xff, (addrVal >> 16) & 0xff, + (addrVal >> 24) & 0xff); + + aAddrMap.Put(indexString, addrString); + } + + return NS_OK; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/PartiallySeekableInputStream.cpp b/netwerk/base/PartiallySeekableInputStream.cpp new file mode 100644 index 0000000000..de1e61c6a5 --- /dev/null +++ b/netwerk/base/PartiallySeekableInputStream.cpp @@ -0,0 +1,437 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "PartiallySeekableInputStream.h" +#include "mozilla/ipc/InputStreamUtils.h" +#include "nsISeekableStream.h" +#include "nsStreamUtils.h" + +namespace mozilla { +namespace net { + +NS_IMPL_ADDREF(PartiallySeekableInputStream); +NS_IMPL_RELEASE(PartiallySeekableInputStream); + +NS_INTERFACE_MAP_BEGIN(PartiallySeekableInputStream) + NS_INTERFACE_MAP_ENTRY(nsIInputStream) + NS_INTERFACE_MAP_ENTRY(nsISeekableStream) + NS_INTERFACE_MAP_ENTRY(nsITellableStream) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsICloneableInputStream, + mWeakCloneableInputStream) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIIPCSerializableInputStream, + mWeakIPCSerializableInputStream) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAsyncInputStream, mWeakAsyncInputStream) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIInputStreamCallback, + mWeakAsyncInputStream) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIInputStreamLength, + mWeakInputStreamLength) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAsyncInputStreamLength, + mWeakAsyncInputStreamLength) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIInputStreamLengthCallback, + mWeakAsyncInputStreamLength) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIInputStream) +NS_INTERFACE_MAP_END + +PartiallySeekableInputStream::PartiallySeekableInputStream( + already_AddRefed<nsIInputStream> aInputStream, uint64_t aBufferSize) + : mInputStream(std::move(aInputStream)), + mWeakCloneableInputStream(nullptr), + mWeakIPCSerializableInputStream(nullptr), + mWeakAsyncInputStream(nullptr), + mWeakInputStreamLength(nullptr), + mWeakAsyncInputStreamLength(nullptr), + mBufferSize(aBufferSize), + mPos(0), + mClosed(false), + mMutex("PartiallySeekableInputStream::mMutex") { + Init(); +} + +PartiallySeekableInputStream::PartiallySeekableInputStream( + already_AddRefed<nsIInputStream> aClonedBaseStream, + PartiallySeekableInputStream* aClonedFrom) + : mInputStream(std::move(aClonedBaseStream)), + mWeakCloneableInputStream(nullptr), + mWeakIPCSerializableInputStream(nullptr), + mWeakAsyncInputStream(nullptr), + mWeakInputStreamLength(nullptr), + mWeakAsyncInputStreamLength(nullptr), + mCachedBuffer(aClonedFrom->mCachedBuffer.Clone()), + mBufferSize(aClonedFrom->mBufferSize), + mPos(aClonedFrom->mPos), + mClosed(aClonedFrom->mClosed), + mMutex("PartiallySeekableInputStream::mMutex") { + Init(); +} + +void PartiallySeekableInputStream::Init() { + MOZ_ASSERT(mInputStream); + +#ifdef DEBUG + nsCOMPtr<nsISeekableStream> seekableStream = do_QueryInterface(mInputStream); + MOZ_ASSERT(!seekableStream); +#endif + + nsCOMPtr<nsICloneableInputStream> cloneableStream = + do_QueryInterface(mInputStream); + if (cloneableStream && SameCOMIdentity(mInputStream, cloneableStream)) { + mWeakCloneableInputStream = cloneableStream; + } + + nsCOMPtr<nsIIPCSerializableInputStream> serializableStream = + do_QueryInterface(mInputStream); + if (serializableStream && SameCOMIdentity(mInputStream, serializableStream)) { + mWeakIPCSerializableInputStream = serializableStream; + } + + nsCOMPtr<nsIAsyncInputStream> asyncInputStream = + do_QueryInterface(mInputStream); + if (asyncInputStream && SameCOMIdentity(mInputStream, asyncInputStream)) { + mWeakAsyncInputStream = asyncInputStream; + } + + nsCOMPtr<nsIInputStreamLength> inputStreamLength = + do_QueryInterface(mInputStream); + if (inputStreamLength && SameCOMIdentity(mInputStream, inputStreamLength)) { + mWeakInputStreamLength = inputStreamLength; + } + + nsCOMPtr<nsIAsyncInputStreamLength> asyncInputStreamLength = + do_QueryInterface(mInputStream); + if (asyncInputStreamLength && + SameCOMIdentity(mInputStream, asyncInputStreamLength)) { + mWeakAsyncInputStreamLength = asyncInputStreamLength; + } +} + +NS_IMETHODIMP +PartiallySeekableInputStream::Close() { + mInputStream->Close(); + mCachedBuffer.Clear(); + mPos = 0; + mClosed = true; + return NS_OK; +} + +// nsIInputStream interface + +NS_IMETHODIMP +PartiallySeekableInputStream::Available(uint64_t* aLength) { + if (mClosed) { + return NS_BASE_STREAM_CLOSED; + } + + nsresult rv = mInputStream->Available(aLength); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + if (mPos < mCachedBuffer.Length()) { + *aLength += mCachedBuffer.Length() - mPos; + } + + return NS_OK; +} + +NS_IMETHODIMP +PartiallySeekableInputStream::Read(char* aBuffer, uint32_t aCount, + uint32_t* aReadCount) { + *aReadCount = 0; + + if (mClosed) { + return NS_OK; + } + + uint32_t byteRead = 0; + + if (mPos < mCachedBuffer.Length()) { + // We are reading from the cached buffer. + byteRead = XPCOM_MIN(mCachedBuffer.Length() - mPos, (uint64_t)aCount); + memcpy(aBuffer, mCachedBuffer.Elements() + mPos, byteRead); + *aReadCount = byteRead; + mPos += byteRead; + } + + if (byteRead < aCount) { + MOZ_ASSERT(mPos >= mCachedBuffer.Length()); + MOZ_ASSERT_IF(mPos > mCachedBuffer.Length(), + mCachedBuffer.Length() == mBufferSize); + + // We can read from the stream. + uint32_t byteWritten; + nsresult rv = + mInputStream->Read(aBuffer + byteRead, aCount - byteRead, &byteWritten); + if (NS_WARN_IF(NS_FAILED(rv)) || byteWritten == 0) { + return rv; + } + + *aReadCount += byteWritten; + + // Maybe we have to cache something. + if (mPos < mBufferSize) { + uint32_t size = XPCOM_MIN(mPos + byteWritten, mBufferSize); + mCachedBuffer.SetLength(size); + memcpy(mCachedBuffer.Elements() + mPos, aBuffer + byteRead, size - mPos); + } + + mPos += byteWritten; + } + + return NS_OK; +} + +NS_IMETHODIMP +PartiallySeekableInputStream::ReadSegments(nsWriteSegmentFun aWriter, + void* aClosure, uint32_t aCount, + uint32_t* aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +PartiallySeekableInputStream::IsNonBlocking(bool* aNonBlocking) { + return mInputStream->IsNonBlocking(aNonBlocking); +} + +// nsICloneableInputStream interface + +NS_IMETHODIMP +PartiallySeekableInputStream::GetCloneable(bool* aCloneable) { + NS_ENSURE_STATE(mWeakCloneableInputStream); + + return mWeakCloneableInputStream->GetCloneable(aCloneable); +} + +NS_IMETHODIMP +PartiallySeekableInputStream::Clone(nsIInputStream** aResult) { + NS_ENSURE_STATE(mWeakCloneableInputStream); + + nsCOMPtr<nsIInputStream> clonedStream; + nsresult rv = mWeakCloneableInputStream->Clone(getter_AddRefs(clonedStream)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + nsCOMPtr<nsIInputStream> stream = + new PartiallySeekableInputStream(clonedStream.forget(), this); + + stream.forget(aResult); + return NS_OK; +} + +// nsIAsyncInputStream interface + +NS_IMETHODIMP +PartiallySeekableInputStream::CloseWithStatus(nsresult aStatus) { + NS_ENSURE_STATE(mWeakAsyncInputStream); + + return mWeakAsyncInputStream->CloseWithStatus(aStatus); +} + +NS_IMETHODIMP +PartiallySeekableInputStream::AsyncWait(nsIInputStreamCallback* aCallback, + uint32_t aFlags, + uint32_t aRequestedCount, + nsIEventTarget* aEventTarget) { + if (mClosed) { + if (aCallback) { + if (aEventTarget) { + nsCOMPtr<nsIInputStreamCallback> callable = NS_NewInputStreamReadyEvent( + "PartiallySeekableInputStream::OnInputStreamReady", aCallback, + aEventTarget); + callable->OnInputStreamReady(this); + } else { + aCallback->OnInputStreamReady(this); + } + } + + return NS_OK; + } + + { + MutexAutoLock lock(mMutex); + if (mAsyncWaitCallback && aCallback) { + return NS_ERROR_FAILURE; + } + + mAsyncWaitCallback = aCallback; + } + + NS_ENSURE_STATE(mWeakAsyncInputStream); + nsCOMPtr<nsIInputStreamCallback> callback = aCallback ? this : nullptr; + return mWeakAsyncInputStream->AsyncWait(callback, aFlags, aRequestedCount, + aEventTarget); +} + +// nsIInputStreamCallback + +NS_IMETHODIMP +PartiallySeekableInputStream::OnInputStreamReady(nsIAsyncInputStream* aStream) { + MOZ_ASSERT(mWeakAsyncInputStream); + MOZ_ASSERT(mWeakAsyncInputStream == aStream); + + nsCOMPtr<nsIInputStreamCallback> callback; + + { + MutexAutoLock lock(mMutex); + + // We have been canceled in the meanwhile. + if (!mAsyncWaitCallback) { + return NS_OK; + } + + callback.swap(mAsyncWaitCallback); + } + + MOZ_ASSERT(callback); + return callback->OnInputStreamReady(this); +} + +// nsIIPCSerializableInputStream + +void PartiallySeekableInputStream::Serialize( + mozilla::ipc::InputStreamParams& aParams, + FileDescriptorArray& aFileDescriptors, bool aDelayedStart, + uint32_t aMaxSize, uint32_t* aSizeUsed, + mozilla::ipc::ParentToChildStreamActorManager* aManager) { + SerializeInternal(aParams, aFileDescriptors, aDelayedStart, aMaxSize, + aSizeUsed, aManager); +} + +void PartiallySeekableInputStream::Serialize( + mozilla::ipc::InputStreamParams& aParams, + FileDescriptorArray& aFileDescriptors, bool aDelayedStart, + uint32_t aMaxSize, uint32_t* aSizeUsed, + mozilla::ipc::ChildToParentStreamActorManager* aManager) { + SerializeInternal(aParams, aFileDescriptors, aDelayedStart, aMaxSize, + aSizeUsed, aManager); +} + +template <typename M> +void PartiallySeekableInputStream::SerializeInternal( + mozilla::ipc::InputStreamParams& aParams, + FileDescriptorArray& aFileDescriptors, bool aDelayedStart, + uint32_t aMaxSize, uint32_t* aSizeUsed, M* aManager) { + MOZ_ASSERT(mWeakIPCSerializableInputStream); + MOZ_DIAGNOSTIC_ASSERT(mCachedBuffer.IsEmpty()); + mozilla::ipc::InputStreamHelper::SerializeInputStream( + mInputStream, aParams, aFileDescriptors, aDelayedStart, aMaxSize, + aSizeUsed, aManager); +} + +bool PartiallySeekableInputStream::Deserialize( + const mozilla::ipc::InputStreamParams& aParams, + const FileDescriptorArray& aFileDescriptors) { + MOZ_CRASH("This method should never be called!"); + return false; +} + +// nsISeekableStream + +NS_IMETHODIMP +PartiallySeekableInputStream::Seek(int32_t aWhence, int64_t aOffset) { + if (mClosed) { + return NS_BASE_STREAM_CLOSED; + } + + int64_t offset; + + switch (aWhence) { + case NS_SEEK_SET: + offset = aOffset; + break; + case NS_SEEK_CUR: + offset = mPos + aOffset; + break; + case NS_SEEK_END: { + return NS_ERROR_NOT_IMPLEMENTED; + } + default: + return NS_ERROR_ILLEGAL_VALUE; + } + + if (offset < 0) { + return NS_ERROR_ILLEGAL_VALUE; + } + + if ((uint64_t)offset >= mCachedBuffer.Length() || mPos > mBufferSize) { + return NS_ERROR_NOT_IMPLEMENTED; + } + + mPos = offset; + return NS_OK; +} + +NS_IMETHODIMP +PartiallySeekableInputStream::Tell(int64_t* aResult) { + if (mClosed) { + return NS_BASE_STREAM_CLOSED; + } + + *aResult = mPos; + return NS_OK; +} + +NS_IMETHODIMP +PartiallySeekableInputStream::SetEOF() { return Close(); } + +// nsIInputStreamLength + +NS_IMETHODIMP +PartiallySeekableInputStream::Length(int64_t* aLength) { + NS_ENSURE_STATE(mWeakInputStreamLength); + return mWeakInputStreamLength->Length(aLength); +} + +// nsIAsyncInputStreamLength + +NS_IMETHODIMP +PartiallySeekableInputStream::AsyncLengthWait( + nsIInputStreamLengthCallback* aCallback, nsIEventTarget* aEventTarget) { + if (mClosed) { + if (aCallback) { + const RefPtr<PartiallySeekableInputStream> self = this; + const nsCOMPtr<nsIInputStreamLengthCallback> callback = aCallback; + nsCOMPtr<nsIRunnable> runnable = NS_NewRunnableFunction( + "PartiallySeekableInputStream::OnInputStreamLengthReady", + [self, callback] { callback->OnInputStreamLengthReady(self, -1); }); + if (aEventTarget) { + aEventTarget->Dispatch(runnable, NS_DISPATCH_NORMAL); + } else { + runnable->Run(); + } + } + return NS_OK; + } + + NS_ENSURE_STATE(mWeakAsyncInputStreamLength); + + nsCOMPtr<nsIInputStreamLengthCallback> callback = aCallback ? this : nullptr; + { + MutexAutoLock lock(mMutex); + mAsyncInputStreamLengthCallback = aCallback; + } + + return mWeakAsyncInputStreamLength->AsyncLengthWait(callback, aEventTarget); +} + +NS_IMETHODIMP +PartiallySeekableInputStream::OnInputStreamLengthReady( + nsIAsyncInputStreamLength* aStream, int64_t aLength) { + nsCOMPtr<nsIInputStreamLengthCallback> callback; + { + MutexAutoLock lock(mMutex); + // We have been canceled in the meanwhile. + if (!mAsyncInputStreamLengthCallback) { + return NS_OK; + } + + callback.swap(mAsyncInputStreamLengthCallback); + } + + return callback->OnInputStreamLengthReady(this, aLength); +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/PartiallySeekableInputStream.h b/netwerk/base/PartiallySeekableInputStream.h new file mode 100644 index 0000000000..92ad4114c5 --- /dev/null +++ b/netwerk/base/PartiallySeekableInputStream.h @@ -0,0 +1,91 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef PartiallySeekableInputStream_h +#define PartiallySeekableInputStream_h + +#include "mozilla/Attributes.h" +#include "mozilla/Mutex.h" +#include "nsCOMPtr.h" +#include "nsIAsyncInputStream.h" +#include "nsICloneableInputStream.h" +#include "nsIInputStreamLength.h" +#include "nsIIPCSerializableInputStream.h" +#include "nsISeekableStream.h" + +namespace mozilla { +namespace net { + +// A wrapper for making a stream seekable for the first |aBufferSize| bytes. +// Note that this object takes the ownership of the underlying stream. + +class PartiallySeekableInputStream final : public nsISeekableStream, + public nsIAsyncInputStream, + public nsICloneableInputStream, + public nsIIPCSerializableInputStream, + public nsIInputStreamCallback, + public nsIInputStreamLength, + public nsIAsyncInputStreamLength, + public nsIInputStreamLengthCallback { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIINPUTSTREAM + NS_DECL_NSISEEKABLESTREAM + NS_DECL_NSITELLABLESTREAM + NS_DECL_NSIASYNCINPUTSTREAM + NS_DECL_NSICLONEABLEINPUTSTREAM + NS_DECL_NSIIPCSERIALIZABLEINPUTSTREAM + NS_DECL_NSIINPUTSTREAMCALLBACK + NS_DECL_NSIINPUTSTREAMLENGTH + NS_DECL_NSIASYNCINPUTSTREAMLENGTH + NS_DECL_NSIINPUTSTREAMLENGTHCALLBACK + + explicit PartiallySeekableInputStream( + already_AddRefed<nsIInputStream> aInputStream, + uint64_t aBufferSize = 4096); + + private: + PartiallySeekableInputStream( + already_AddRefed<nsIInputStream> aClonedBaseStream, + PartiallySeekableInputStream* aClonedFrom); + + ~PartiallySeekableInputStream() = default; + + void Init(); + + template <typename M> + void SerializeInternal(mozilla::ipc::InputStreamParams& aParams, + FileDescriptorArray& aFileDescriptors, + bool aDelayedStart, uint32_t aMaxSize, + uint32_t* aSizeUsed, M* aManager); + + nsCOMPtr<nsIInputStream> mInputStream; + + // Raw pointers because these are just QI of mInputStream. + nsICloneableInputStream* mWeakCloneableInputStream; + nsIIPCSerializableInputStream* mWeakIPCSerializableInputStream; + nsIAsyncInputStream* mWeakAsyncInputStream; + nsIInputStreamLength* mWeakInputStreamLength; + nsIAsyncInputStreamLength* mWeakAsyncInputStreamLength; + + // Protected by mutex. + nsCOMPtr<nsIInputStreamCallback> mAsyncWaitCallback; + + // Protected by mutex. + nsCOMPtr<nsIInputStreamLengthCallback> mAsyncInputStreamLengthCallback; + + nsTArray<char> mCachedBuffer; + + uint64_t mBufferSize; + uint64_t mPos; + bool mClosed; + + Mutex mMutex; +}; + +} // namespace net +} // namespace mozilla + +#endif // PartiallySeekableInputStream_h diff --git a/netwerk/base/PollableEvent.cpp b/netwerk/base/PollableEvent.cpp new file mode 100644 index 0000000000..b483ee6cd0 --- /dev/null +++ b/netwerk/base/PollableEvent.cpp @@ -0,0 +1,401 @@ +/* -*- 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 "nsSocketTransportService2.h" +#include "PollableEvent.h" +#include "mozilla/Assertions.h" +#include "mozilla/DebugOnly.h" +#include "mozilla/Logging.h" +#include "prerror.h" +#include "prio.h" +#include "private/pprio.h" +#include "prnetdb.h" + +#ifdef XP_WIN +# include "ShutdownLayer.h" +#else +# include <fcntl.h> +# define USEPIPE 1 +#endif + +namespace mozilla { +namespace net { + +#ifndef USEPIPE +static PRDescIdentity sPollableEventLayerIdentity; +static PRIOMethods sPollableEventLayerMethods; +static PRIOMethods* sPollableEventLayerMethodsPtr = nullptr; + +static void LazyInitSocket() { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + if (sPollableEventLayerMethodsPtr) { + return; + } + sPollableEventLayerIdentity = PR_GetUniqueIdentity("PollableEvent Layer"); + sPollableEventLayerMethods = *PR_GetDefaultIOMethods(); + sPollableEventLayerMethodsPtr = &sPollableEventLayerMethods; +} + +static bool NewTCPSocketPair(PRFileDesc* fd[], bool aSetRecvBuff) { + // this is a replacement for PR_NewTCPSocketPair that manually + // sets the recv buffer to 64K. A windows bug (1248358) + // can result in using an incompatible rwin and window + // scale option on localhost pipes if not set before connect. + + SOCKET_LOG(("NewTCPSocketPair %s a recv buffer tuning\n", + aSetRecvBuff ? "with" : "without")); + + PRFileDesc* listener = nullptr; + PRFileDesc* writer = nullptr; + PRFileDesc* reader = nullptr; + PRSocketOptionData recvBufferOpt; + recvBufferOpt.option = PR_SockOpt_RecvBufferSize; + recvBufferOpt.value.recv_buffer_size = 65535; + + PRSocketOptionData nodelayOpt; + nodelayOpt.option = PR_SockOpt_NoDelay; + nodelayOpt.value.no_delay = true; + + PRSocketOptionData noblockOpt; + noblockOpt.option = PR_SockOpt_Nonblocking; + noblockOpt.value.non_blocking = true; + + listener = PR_OpenTCPSocket(PR_AF_INET); + if (!listener) { + goto failed; + } + + if (aSetRecvBuff) { + PR_SetSocketOption(listener, &recvBufferOpt); + } + PR_SetSocketOption(listener, &nodelayOpt); + + PRNetAddr listenAddr; + memset(&listenAddr, 0, sizeof(listenAddr)); + if ((PR_InitializeNetAddr(PR_IpAddrLoopback, 0, &listenAddr) == PR_FAILURE) || + (PR_Bind(listener, &listenAddr) == PR_FAILURE) || + (PR_GetSockName(listener, &listenAddr) == + PR_FAILURE) || // learn the dynamic port + (PR_Listen(listener, 5) == PR_FAILURE)) { + goto failed; + } + + writer = PR_OpenTCPSocket(PR_AF_INET); + if (!writer) { + goto failed; + } + if (aSetRecvBuff) { + PR_SetSocketOption(writer, &recvBufferOpt); + } + PR_SetSocketOption(writer, &nodelayOpt); + PR_SetSocketOption(writer, &noblockOpt); + PRNetAddr writerAddr; + if (PR_InitializeNetAddr(PR_IpAddrLoopback, ntohs(listenAddr.inet.port), + &writerAddr) == PR_FAILURE) { + goto failed; + } + + if (PR_Connect(writer, &writerAddr, PR_INTERVAL_NO_TIMEOUT) == PR_FAILURE) { + if ((PR_GetError() != PR_IN_PROGRESS_ERROR) || + (PR_ConnectContinue(writer, PR_POLL_WRITE) == PR_FAILURE)) { + goto failed; + } + } + PR_SetFDInheritable(writer, false); + + reader = PR_Accept(listener, &listenAddr, PR_MillisecondsToInterval(200)); + if (!reader) { + goto failed; + } + PR_SetFDInheritable(reader, false); + if (aSetRecvBuff) { + PR_SetSocketOption(reader, &recvBufferOpt); + } + PR_SetSocketOption(reader, &nodelayOpt); + PR_SetSocketOption(reader, &noblockOpt); + PR_Close(listener); + + fd[0] = reader; + fd[1] = writer; + return true; + +failed: + if (listener) { + PR_Close(listener); + } + if (reader) { + PR_Close(reader); + } + if (writer) { + PR_Close(writer); + } + return false; +} + +#endif + +PollableEvent::PollableEvent() + : mWriteFD(nullptr), + mReadFD(nullptr), + mSignaled(false), + mWriteFailed(false), + mSignalTimestampAdjusted(false) { + MOZ_COUNT_CTOR(PollableEvent); + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + // create pair of prfiledesc that can be used as a poll()ble + // signal. on windows use a localhost socket pair, and on + // unix use a pipe. +#ifdef USEPIPE + SOCKET_LOG(("PollableEvent() using pipe\n")); + if (PR_CreatePipe(&mReadFD, &mWriteFD) == PR_SUCCESS) { + // make the pipe non blocking. NSPR asserts at + // trying to use SockOpt here + PROsfd fd = PR_FileDesc2NativeHandle(mReadFD); + int flags = fcntl(fd, F_GETFL, 0); + (void)fcntl(fd, F_SETFL, flags | O_NONBLOCK); + fd = PR_FileDesc2NativeHandle(mWriteFD); + flags = fcntl(fd, F_GETFL, 0); + (void)fcntl(fd, F_SETFL, flags | O_NONBLOCK); + } else { + mReadFD = nullptr; + mWriteFD = nullptr; + SOCKET_LOG(("PollableEvent() pipe failed\n")); + } +#else + SOCKET_LOG(("PollableEvent() using socket pair\n")); + PRFileDesc* fd[2]; + LazyInitSocket(); + + // Try with a increased recv buffer first (bug 1248358). + if (NewTCPSocketPair(fd, true)) { + mReadFD = fd[0]; + mWriteFD = fd[1]; + // If the previous fails try without recv buffer increase (bug 1305436). + } else if (NewTCPSocketPair(fd, false)) { + mReadFD = fd[0]; + mWriteFD = fd[1]; + // If both fail, try the old version. + } else if (PR_NewTCPSocketPair(fd) == PR_SUCCESS) { + mReadFD = fd[0]; + mWriteFD = fd[1]; + + PRSocketOptionData socket_opt; + DebugOnly<PRStatus> status; + socket_opt.option = PR_SockOpt_NoDelay; + socket_opt.value.no_delay = true; + PR_SetSocketOption(mWriteFD, &socket_opt); + PR_SetSocketOption(mReadFD, &socket_opt); + socket_opt.option = PR_SockOpt_Nonblocking; + socket_opt.value.non_blocking = true; + status = PR_SetSocketOption(mWriteFD, &socket_opt); + MOZ_ASSERT(status == PR_SUCCESS); + status = PR_SetSocketOption(mReadFD, &socket_opt); + MOZ_ASSERT(status == PR_SUCCESS); + } + + if (mReadFD && mWriteFD) { + // compatibility with LSPs such as McAfee that assume a NSPR + // layer for read ala the nspr Pollable Event - Bug 698882. This layer is a + // nop. + PRFileDesc* topLayer = PR_CreateIOLayerStub(sPollableEventLayerIdentity, + sPollableEventLayerMethodsPtr); + if (topLayer) { + if (PR_PushIOLayer(fd[0], PR_TOP_IO_LAYER, topLayer) == PR_FAILURE) { + topLayer->dtor(topLayer); + } else { + SOCKET_LOG(("PollableEvent() nspr layer ok\n")); + mReadFD = topLayer; + } + } + + } else { + SOCKET_LOG(("PollableEvent() socketpair failed\n")); + } +#endif + + if (mReadFD && mWriteFD) { + // prime the system to deal with races invovled in [dc]tor cycle + SOCKET_LOG(("PollableEvent() ctor ok\n")); + mSignaled = true; + MarkFirstSignalTimestamp(); + PR_Write(mWriteFD, "I", 1); + } +} + +PollableEvent::~PollableEvent() { + MOZ_COUNT_DTOR(PollableEvent); + if (mWriteFD) { +#if defined(XP_WIN) + AttachShutdownLayer(mWriteFD); +#endif + PR_Close(mWriteFD); + } + if (mReadFD) { +#if defined(XP_WIN) + AttachShutdownLayer(mReadFD); +#endif + PR_Close(mReadFD); + } +} + +// we do not record signals on the socket thread +// because the socket thread can reliably look at its +// own runnable queue before selecting a poll time +// this is the "service the network without blocking" comment in +// nsSocketTransportService2.cpp +bool PollableEvent::Signal() { + SOCKET_LOG(("PollableEvent::Signal\n")); + + if (!mWriteFD) { + SOCKET_LOG(("PollableEvent::Signal Failed on no FD\n")); + return false; + } +#ifndef XP_WIN + // On windows poll can hang and this became worse when we introduced the + // patch for bug 698882 (see also bug 1292181), therefore we reverted the + // behavior on windows to be as before bug 698882, e.g. write to the socket + // also if an event dispatch is on the socket thread and writing to the + // socket for each event. See bug 1292181. + if (OnSocketThread()) { + SOCKET_LOG(("PollableEvent::Signal OnSocketThread nop\n")); + return true; + } +#endif + +#ifndef XP_WIN + // To wake up the poll writing once is enough, but for Windows that can cause + // hangs so we will write for every event. + // For non-Windows systems it is enough to write just once. + if (mSignaled) { + return true; + } +#endif + + if (!mSignaled) { + mSignaled = true; + MarkFirstSignalTimestamp(); + } + + int32_t status = PR_Write(mWriteFD, "M", 1); + SOCKET_LOG(("PollableEvent::Signal PR_Write %d\n", status)); + if (status != 1) { + NS_WARNING("PollableEvent::Signal Failed\n"); + SOCKET_LOG(("PollableEvent::Signal Failed\n")); + mSignaled = false; + mWriteFailed = true; + } else { + mWriteFailed = false; + } + return (status == 1); +} + +bool PollableEvent::Clear() { + // necessary because of the "dont signal on socket thread" optimization + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + SOCKET_LOG(("PollableEvent::Clear\n")); + + if (!mFirstSignalAfterClear.IsNull()) { + SOCKET_LOG(("PollableEvent::Clear time to signal %ums", + (uint32_t)(TimeStamp::NowLoRes() - mFirstSignalAfterClear) + .ToMilliseconds())); + } + + mFirstSignalAfterClear = TimeStamp(); + mSignalTimestampAdjusted = false; + mSignaled = false; + + if (!mReadFD) { + SOCKET_LOG(("PollableEvent::Clear mReadFD is null\n")); + return false; + } + + char buf[2048]; + int32_t status; +#ifdef XP_WIN + // On Windows we are writing to the socket for each event, to be sure that we + // do not have any deadlock read from the socket as much as we can. + while (true) { + status = PR_Read(mReadFD, buf, 2048); + SOCKET_LOG(("PollableEvent::Clear PR_Read %d\n", status)); + if (status == 0) { + SOCKET_LOG(("PollableEvent::Clear EOF!\n")); + return false; + } + if (status < 0) { + PRErrorCode code = PR_GetError(); + if (code == PR_WOULD_BLOCK_ERROR) { + return true; + } else { + SOCKET_LOG(("PollableEvent::Clear unexpected error %d\n", code)); + return false; + } + } + } +#else + status = PR_Read(mReadFD, buf, 2048); + SOCKET_LOG(("PollableEvent::Clear PR_Read %d\n", status)); + + if (status == 1) { + return true; + } + if (status == 0) { + SOCKET_LOG(("PollableEvent::Clear EOF!\n")); + return false; + } + if (status > 1) { + MOZ_ASSERT(false); + SOCKET_LOG(("PollableEvent::Clear Unexpected events\n")); + Clear(); + return true; + } + PRErrorCode code = PR_GetError(); + if (code == PR_WOULD_BLOCK_ERROR) { + return true; + } + SOCKET_LOG(("PollableEvent::Clear unexpected error %d\n", code)); + return false; +#endif // XP_WIN +} + +void PollableEvent::MarkFirstSignalTimestamp() { + if (mFirstSignalAfterClear.IsNull()) { + SOCKET_LOG(("PollableEvent::MarkFirstSignalTimestamp")); + mFirstSignalAfterClear = TimeStamp::NowLoRes(); + } +} + +void PollableEvent::AdjustFirstSignalTimestamp() { + if (!mSignalTimestampAdjusted && !mFirstSignalAfterClear.IsNull()) { + SOCKET_LOG(("PollableEvent::AdjustFirstSignalTimestamp")); + mFirstSignalAfterClear = TimeStamp::NowLoRes(); + mSignalTimestampAdjusted = true; + } +} + +bool PollableEvent::IsSignallingAlive(TimeDuration const& timeout) { + if (mWriteFailed) { + return false; + } + +#ifdef DEBUG + // The timeout would be just a disturbance in a debug build. + return true; +#else + if (!mSignaled || mFirstSignalAfterClear.IsNull() || + timeout == TimeDuration()) { + return true; + } + + TimeDuration delay = (TimeStamp::NowLoRes() - mFirstSignalAfterClear); + bool timedOut = delay > timeout; + + return !timedOut; +#endif // DEBUG +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/PollableEvent.h b/netwerk/base/PollableEvent.h new file mode 100644 index 0000000000..feb637f6cc --- /dev/null +++ b/netwerk/base/PollableEvent.h @@ -0,0 +1,67 @@ +/* -*- 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/. */ + +#ifndef PollableEvent_h__ +#define PollableEvent_h__ + +#include "mozilla/Mutex.h" +#include "mozilla/TimeStamp.h" + +struct PRFileDesc; + +namespace mozilla { +namespace net { + +// class must be called locked +class PollableEvent { + public: + PollableEvent(); + ~PollableEvent(); + + // Signal/Clear return false only if they fail + bool Signal(); + // This is called only when we get non-null out_flags for the socket pair + bool Clear(); + bool Valid() { return mWriteFD && mReadFD; } + + // We want to detect if writing to one of the socket pair sockets takes + // too long to be received by the other socket from the pair. + // Hence, we remember the timestamp of the earliest write by a call to + // MarkFirstSignalTimestamp() from Signal(). After waking up from poll() + // we check how long it took get the 'readable' signal on the socket pair. + void MarkFirstSignalTimestamp(); + // Called right before we enter poll() to exclude any possible delay between + // the earlist call to Signal() and entering poll() caused by processing + // of events dispatched to the socket transport thread. + void AdjustFirstSignalTimestamp(); + // This returns false on following conditions: + // - PR_Write has failed + // - no out_flags were signalled on the socket pair for too long after + // the earliest Signal() + bool IsSignallingAlive(TimeDuration const& timeout); + + PRFileDesc* PollableFD() { return mReadFD; } + + private: + PRFileDesc* mWriteFD; + PRFileDesc* mReadFD; + bool mSignaled; + // true when PR_Write to the socket pair has failed (status < 1) + bool mWriteFailed; + // Set true after AdjustFirstSignalTimestamp() was called + // Set false after Clear() was called + // Ensures shifting the timestamp before entering poll() only once + // between Clear()'ings. + bool mSignalTimestampAdjusted; + // Timestamp of the first call to Signal() (or time we enter poll()) + // that happened after the last Clear() call + TimeStamp mFirstSignalAfterClear; +}; + +} // namespace net +} // namespace mozilla + +#endif diff --git a/netwerk/base/Predictor.cpp b/netwerk/base/Predictor.cpp new file mode 100644 index 0000000000..95aeef06f4 --- /dev/null +++ b/netwerk/base/Predictor.cpp @@ -0,0 +1,2445 @@ +/* vim: set ts=2 sts=2 et sw=2: */ +/* 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 <algorithm> + +#include "Predictor.h" + +#include "nsAppDirectoryServiceDefs.h" +#include "nsICacheStorage.h" +#include "nsICachingChannel.h" +#include "nsICancelable.h" +#include "nsIChannel.h" +#include "nsContentUtils.h" +#include "nsIDNSService.h" +#include "mozilla/dom/Document.h" +#include "nsIFile.h" +#include "nsIHttpChannel.h" +#include "nsIInputStream.h" +#include "nsILoadContext.h" +#include "nsILoadContextInfo.h" +#include "nsILoadGroup.h" +#include "nsINetworkPredictorVerifier.h" +#include "nsIObserverService.h" +#include "nsISpeculativeConnect.h" +#include "nsITimer.h" +#include "nsIURI.h" +#include "nsNetUtil.h" +#include "nsServiceManagerUtils.h" +#include "nsStreamUtils.h" +#include "nsString.h" +#include "nsThreadUtils.h" +#include "mozilla/Logging.h" + +#include "mozilla/OriginAttributes.h" +#include "mozilla/Preferences.h" +#include "mozilla/SchedulerGroup.h" +#include "mozilla/StaticPrefs_network.h" +#include "mozilla/Telemetry.h" + +#include "mozilla/net/NeckoCommon.h" +#include "mozilla/net/NeckoParent.h" + +#include "LoadContextInfo.h" +#include "mozilla/ipc/URIUtils.h" +#include "SerializedLoadContext.h" +#include "mozilla/net/NeckoChild.h" + +#include "mozilla/dom/ContentParent.h" +#include "mozilla/ClearOnShutdown.h" + +#include "CacheControlParser.h" +#include "ReferrerInfo.h" + +using namespace mozilla; + +namespace mozilla { +namespace net { + +Predictor* Predictor::sSelf = nullptr; + +static LazyLogModule gPredictorLog("NetworkPredictor"); + +#define PREDICTOR_LOG(args) \ + MOZ_LOG(gPredictorLog, mozilla::LogLevel::Debug, args) + +#define NOW_IN_SECONDS() static_cast<uint32_t>(PR_Now() / PR_USEC_PER_SEC) + +// All these time values are in sec +static const uint32_t ONE_DAY = 86400U; +static const uint32_t ONE_WEEK = 7U * ONE_DAY; +static const uint32_t ONE_MONTH = 30U * ONE_DAY; +static const uint32_t ONE_YEAR = 365U * ONE_DAY; + +static const uint32_t STARTUP_WINDOW = 5U * 60U; // 5min + +// Version of metadata entries we expect +static const uint32_t METADATA_VERSION = 1; + +// Flags available in entries +// FLAG_PREFETCHABLE - we have determined that this item is eligible for +// prefetch +static const uint32_t FLAG_PREFETCHABLE = 1 << 0; + +// We save 12 bits in the "flags" section of our metadata for actual flags, the +// rest are to keep track of a rolling count of which loads a resource has been +// used on to determine if we can prefetch that resource or not; +static const uint8_t kRollingLoadOffset = 12; +static const int32_t kMaxPrefetchRollingLoadCount = 20; +static const uint32_t kFlagsMask = ((1 << kRollingLoadOffset) - 1); + +// ID Extensions for cache entries +#define PREDICTOR_ORIGIN_EXTENSION "predictor-origin" + +// Get the full origin (scheme, host, port) out of a URI (maybe should be part +// of nsIURI instead?) +static nsresult ExtractOrigin(nsIURI* uri, nsIURI** originUri) { + nsAutoCString s; + nsresult rv = nsContentUtils::GetASCIIOrigin(uri, s); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_NewURI(originUri, s); +} + +// All URIs we get passed *must* be http or https if they're not null. This +// helps ensure that. +static bool IsNullOrHttp(nsIURI* uri) { + if (!uri) { + return true; + } + + return uri->SchemeIs("http") || uri->SchemeIs("https"); +} + +// Listener for the speculative DNS requests we'll fire off, which just ignores +// the result (since we're just trying to warm the cache). This also exists to +// reduce round-trips to the main thread, by being something threadsafe the +// Predictor can use. + +NS_IMPL_ISUPPORTS(Predictor::DNSListener, nsIDNSListener); + +NS_IMETHODIMP +Predictor::DNSListener::OnLookupComplete(nsICancelable* request, + nsIDNSRecord* rec, nsresult status) { + return NS_OK; +} + +// Class to proxy important information from the initial predictor call through +// the cache API and back into the internals of the predictor. We can't use the +// predictor itself, as it may have multiple actions in-flight, and each action +// has different parameters. +NS_IMPL_ISUPPORTS(Predictor::Action, nsICacheEntryOpenCallback); + +Predictor::Action::Action(bool fullUri, bool predict, Predictor::Reason reason, + nsIURI* targetURI, nsIURI* sourceURI, + nsINetworkPredictorVerifier* verifier, + Predictor* predictor) + : mFullUri(fullUri), + mPredict(predict), + mTargetURI(targetURI), + mSourceURI(sourceURI), + mVerifier(verifier), + mStackCount(0), + mPredictor(predictor) { + mStartTime = TimeStamp::Now(); + if (mPredict) { + mPredictReason = reason.mPredict; + } else { + mLearnReason = reason.mLearn; + } +} + +Predictor::Action::Action(bool fullUri, bool predict, Predictor::Reason reason, + nsIURI* targetURI, nsIURI* sourceURI, + nsINetworkPredictorVerifier* verifier, + Predictor* predictor, uint8_t stackCount) + : mFullUri(fullUri), + mPredict(predict), + mTargetURI(targetURI), + mSourceURI(sourceURI), + mVerifier(verifier), + mStackCount(stackCount), + mPredictor(predictor) { + mStartTime = TimeStamp::Now(); + if (mPredict) { + mPredictReason = reason.mPredict; + } else { + mLearnReason = reason.mLearn; + } +} + +NS_IMETHODIMP +Predictor::Action::OnCacheEntryCheck(nsICacheEntry* entry, + nsIApplicationCache* appCache, + uint32_t* result) { + *result = nsICacheEntryOpenCallback::ENTRY_WANTED; + return NS_OK; +} + +NS_IMETHODIMP +Predictor::Action::OnCacheEntryAvailable(nsICacheEntry* entry, bool isNew, + nsIApplicationCache* appCache, + nsresult result) { + MOZ_ASSERT(NS_IsMainThread(), "Got cache entry off main thread!"); + + nsAutoCString targetURI, sourceURI; + mTargetURI->GetAsciiSpec(targetURI); + if (mSourceURI) { + mSourceURI->GetAsciiSpec(sourceURI); + } + PREDICTOR_LOG( + ("OnCacheEntryAvailable %p called. entry=%p mFullUri=%d mPredict=%d " + "mPredictReason=%d mLearnReason=%d mTargetURI=%s " + "mSourceURI=%s mStackCount=%d isNew=%d result=0x%08" PRIx32, + this, entry, mFullUri, mPredict, mPredictReason, mLearnReason, + targetURI.get(), sourceURI.get(), mStackCount, isNew, + static_cast<uint32_t>(result))); + if (NS_FAILED(result)) { + PREDICTOR_LOG( + ("OnCacheEntryAvailable %p FAILED to get cache entry (0x%08" PRIX32 + "). Aborting.", + this, static_cast<uint32_t>(result))); + return NS_OK; + } + Telemetry::AccumulateTimeDelta(Telemetry::PREDICTOR_WAIT_TIME, mStartTime); + if (mPredict) { + bool predicted = + mPredictor->PredictInternal(mPredictReason, entry, isNew, mFullUri, + mTargetURI, mVerifier, mStackCount); + Telemetry::AccumulateTimeDelta(Telemetry::PREDICTOR_PREDICT_WORK_TIME, + mStartTime); + if (predicted) { + Telemetry::AccumulateTimeDelta( + Telemetry::PREDICTOR_PREDICT_TIME_TO_ACTION, mStartTime); + } else { + Telemetry::AccumulateTimeDelta( + Telemetry::PREDICTOR_PREDICT_TIME_TO_INACTION, mStartTime); + } + } else { + mPredictor->LearnInternal(mLearnReason, entry, isNew, mFullUri, mTargetURI, + mSourceURI); + Telemetry::AccumulateTimeDelta(Telemetry::PREDICTOR_LEARN_WORK_TIME, + mStartTime); + } + + return NS_OK; +} + +NS_IMPL_ISUPPORTS(Predictor, nsINetworkPredictor, nsIObserver, + nsISpeculativeConnectionOverrider, nsIInterfaceRequestor, + nsICacheEntryMetaDataVisitor, nsINetworkPredictorVerifier) + +Predictor::Predictor() + : mInitialized(false), + mStartupTime(0), + mLastStartupTime(0), + mStartupCount(1) { + MOZ_ASSERT(!sSelf, "multiple Predictor instances!"); + sSelf = this; +} + +Predictor::~Predictor() { + if (mInitialized) Shutdown(); + + sSelf = nullptr; +} + +// Predictor::nsIObserver + +nsresult Predictor::InstallObserver() { + MOZ_ASSERT(NS_IsMainThread(), "Installing observer off main thread"); + + nsresult rv = NS_OK; + nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); + if (!obs) { + return NS_ERROR_NOT_AVAILABLE; + } + + rv = obs->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false); + NS_ENSURE_SUCCESS(rv, rv); + + return rv; +} + +void Predictor::RemoveObserver() { + MOZ_ASSERT(NS_IsMainThread(), "Removing observer off main thread"); + + nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); + if (obs) { + obs->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID); + } +} + +NS_IMETHODIMP +Predictor::Observe(nsISupports* subject, const char* topic, + const char16_t* data_unicode) { + nsresult rv = NS_OK; + MOZ_ASSERT(NS_IsMainThread(), + "Predictor observing something off main thread!"); + + if (!strcmp(NS_XPCOM_SHUTDOWN_OBSERVER_ID, topic)) { + Shutdown(); + } + + return rv; +} + +// Predictor::nsISpeculativeConnectionOverrider + +NS_IMETHODIMP +Predictor::GetIgnoreIdle(bool* ignoreIdle) { + *ignoreIdle = true; + return NS_OK; +} + +NS_IMETHODIMP +Predictor::GetParallelSpeculativeConnectLimit( + uint32_t* parallelSpeculativeConnectLimit) { + *parallelSpeculativeConnectLimit = 6; + return NS_OK; +} + +NS_IMETHODIMP +Predictor::GetIsFromPredictor(bool* isFromPredictor) { + *isFromPredictor = true; + return NS_OK; +} + +NS_IMETHODIMP +Predictor::GetAllow1918(bool* allow1918) { + *allow1918 = false; + return NS_OK; +} + +// Predictor::nsIInterfaceRequestor + +NS_IMETHODIMP +Predictor::GetInterface(const nsIID& iid, void** result) { + return QueryInterface(iid, result); +} + +// Predictor::nsICacheEntryMetaDataVisitor + +#define SEEN_META_DATA "predictor::seen" +#define RESOURCE_META_DATA "predictor::resource-count" +#define META_DATA_PREFIX "predictor::" + +static bool IsURIMetadataElement(const char* key) { + return StringBeginsWith(nsDependentCString(key), + nsLiteralCString(META_DATA_PREFIX)) && + !nsLiteralCString(SEEN_META_DATA).Equals(key) && + !nsLiteralCString(RESOURCE_META_DATA).Equals(key); +} + +nsresult Predictor::OnMetaDataElement(const char* asciiKey, + const char* asciiValue) { + MOZ_ASSERT(NS_IsMainThread()); + + if (!IsURIMetadataElement(asciiKey)) { + // This isn't a bit of metadata we care about + return NS_OK; + } + + nsCString key, value; + key.AssignASCII(asciiKey); + value.AssignASCII(asciiValue); + mKeysToOperateOn.AppendElement(key); + mValuesToOperateOn.AppendElement(value); + + return NS_OK; +} + +// Predictor::nsINetworkPredictor + +nsresult Predictor::Init() { + MOZ_DIAGNOSTIC_ASSERT(!IsNeckoChild()); + + if (!NS_IsMainThread()) { + MOZ_ASSERT(false, "Predictor::Init called off the main thread!"); + return NS_ERROR_UNEXPECTED; + } + + nsresult rv = NS_OK; + + rv = InstallObserver(); + NS_ENSURE_SUCCESS(rv, rv); + + mLastStartupTime = mStartupTime = NOW_IN_SECONDS(); + + if (!mDNSListener) { + mDNSListener = new DNSListener(); + } + + mCacheStorageService = + do_GetService("@mozilla.org/netwerk/cache-storage-service;1", &rv); + NS_ENSURE_SUCCESS(rv, rv); + + mSpeculativeService = do_GetService("@mozilla.org/network/io-service;1", &rv); + NS_ENSURE_SUCCESS(rv, rv); + + rv = NS_NewURI(getter_AddRefs(mStartupURI), "predictor://startup"); + NS_ENSURE_SUCCESS(rv, rv); + + mDnsService = do_GetService("@mozilla.org/network/dns-service;1", &rv); + NS_ENSURE_SUCCESS(rv, rv); + + mInitialized = true; + + return rv; +} + +namespace { +class PredictorLearnRunnable final : public Runnable { + public: + PredictorLearnRunnable(nsIURI* targetURI, nsIURI* sourceURI, + PredictorLearnReason reason, + const OriginAttributes& oa) + : Runnable("PredictorLearnRunnable"), + mTargetURI(targetURI), + mSourceURI(sourceURI), + mReason(reason), + mOA(oa) { + MOZ_DIAGNOSTIC_ASSERT(targetURI, "Must have a target URI"); + } + + ~PredictorLearnRunnable() = default; + + NS_IMETHOD Run() override { + if (!gNeckoChild) { + // This may have gone away between when this runnable was dispatched and + // when it actually runs, so let's be safe here, even though we asserted + // earlier. + PREDICTOR_LOG(("predictor::learn (async) gNeckoChild went away")); + return NS_OK; + } + + PREDICTOR_LOG(("predictor::learn (async) forwarding to parent")); + gNeckoChild->SendPredLearn(mTargetURI, mSourceURI, mReason, mOA); + + return NS_OK; + } + + private: + nsCOMPtr<nsIURI> mTargetURI; + nsCOMPtr<nsIURI> mSourceURI; + PredictorLearnReason mReason; + const OriginAttributes mOA; +}; + +} // namespace + +void Predictor::Shutdown() { + if (!NS_IsMainThread()) { + MOZ_ASSERT(false, "Predictor::Shutdown called off the main thread!"); + return; + } + + RemoveObserver(); + + mInitialized = false; +} + +nsresult Predictor::Create(nsISupports* aOuter, const nsIID& aIID, + void** aResult) { + MOZ_ASSERT(NS_IsMainThread()); + + nsresult rv; + + if (aOuter != nullptr) { + return NS_ERROR_NO_AGGREGATION; + } + + RefPtr<Predictor> svc = new Predictor(); + if (IsNeckoChild()) { + NeckoChild::InitNeckoChild(); + + // Child threads only need to be call into the public interface methods + // so we don't bother with initialization + return svc->QueryInterface(aIID, aResult); + } + + rv = svc->Init(); + if (NS_FAILED(rv)) { + PREDICTOR_LOG(("Failed to initialize predictor, predictor will be a noop")); + } + + // We treat init failure the same as the service being disabled, since this + // is all an optimization anyway. No need to freak people out. That's why we + // gladly continue on QI'ing here. + rv = svc->QueryInterface(aIID, aResult); + + return rv; +} + +NS_IMETHODIMP +Predictor::Predict(nsIURI* targetURI, nsIURI* sourceURI, + PredictorPredictReason reason, + JS::HandleValue originAttributes, + nsINetworkPredictorVerifier* verifier, JSContext* aCx) { + OriginAttributes attrs; + + if (!originAttributes.isObject() || !attrs.Init(aCx, originAttributes)) { + return NS_ERROR_INVALID_ARG; + } + + return PredictNative(targetURI, sourceURI, reason, attrs, verifier); +} + +// Called from the main thread to initiate predictive actions +NS_IMETHODIMP +Predictor::PredictNative(nsIURI* targetURI, nsIURI* sourceURI, + PredictorPredictReason reason, + const OriginAttributes& originAttributes, + nsINetworkPredictorVerifier* verifier) { + MOZ_ASSERT(NS_IsMainThread(), + "Predictor interface methods must be called on the main thread"); + + PREDICTOR_LOG(("Predictor::Predict")); + + if (IsNeckoChild()) { + MOZ_DIAGNOSTIC_ASSERT(gNeckoChild); + + PREDICTOR_LOG((" called on child process")); + // If two different threads are predicting concurently, this will be + // overwritten. Thankfully, we only use this in tests, which will + // overwrite mVerifier perhaps multiple times for each individual test; + // however, within each test, the multiple predict calls should have the + // same verifier. + if (verifier) { + PREDICTOR_LOG((" was given a verifier")); + mChildVerifier = verifier; + } + PREDICTOR_LOG((" forwarding to parent process")); + gNeckoChild->SendPredPredict(targetURI, sourceURI, reason, originAttributes, + verifier); + return NS_OK; + } + + PREDICTOR_LOG((" called on parent process")); + + if (!mInitialized) { + PREDICTOR_LOG((" not initialized")); + return NS_OK; + } + + if (!StaticPrefs::network_predictor_enabled()) { + PREDICTOR_LOG((" not enabled")); + return NS_OK; + } + + if (originAttributes.mPrivateBrowsingId > 0) { + // Don't want to do anything in PB mode + PREDICTOR_LOG((" in PB mode")); + return NS_OK; + } + + if (!IsNullOrHttp(targetURI) || !IsNullOrHttp(sourceURI)) { + // Nothing we can do for non-HTTP[S] schemes + PREDICTOR_LOG((" got non-http[s] URI")); + return NS_OK; + } + + // Ensure we've been given the appropriate arguments for the kind of + // prediction we're being asked to do + nsCOMPtr<nsIURI> uriKey = targetURI; + nsCOMPtr<nsIURI> originKey; + switch (reason) { + case nsINetworkPredictor::PREDICT_LINK: + if (!targetURI || !sourceURI) { + PREDICTOR_LOG((" link invalid URI state")); + return NS_ERROR_INVALID_ARG; + } + // Link hover is a special case where we can predict without hitting the + // db, so let's go ahead and fire off that prediction here. + PredictForLink(targetURI, sourceURI, originAttributes, verifier); + return NS_OK; + case nsINetworkPredictor::PREDICT_LOAD: + if (!targetURI || sourceURI) { + PREDICTOR_LOG((" load invalid URI state")); + return NS_ERROR_INVALID_ARG; + } + break; + case nsINetworkPredictor::PREDICT_STARTUP: + if (targetURI || sourceURI) { + PREDICTOR_LOG((" startup invalid URI state")); + return NS_ERROR_INVALID_ARG; + } + uriKey = mStartupURI; + originKey = mStartupURI; + break; + default: + PREDICTOR_LOG((" invalid reason")); + return NS_ERROR_INVALID_ARG; + } + + Predictor::Reason argReason; + argReason.mPredict = reason; + + // First we open the regular cache entry, to ensure we don't gum up the works + // waiting on the less-important predictor-only cache entry + RefPtr<Predictor::Action> uriAction = new Predictor::Action( + Predictor::Action::IS_FULL_URI, Predictor::Action::DO_PREDICT, argReason, + targetURI, nullptr, verifier, this); + nsAutoCString uriKeyStr; + uriKey->GetAsciiSpec(uriKeyStr); + PREDICTOR_LOG((" Predict uri=%s reason=%d action=%p", uriKeyStr.get(), + reason, uriAction.get())); + + nsCOMPtr<nsICacheStorage> cacheDiskStorage; + + RefPtr<LoadContextInfo> lci = new LoadContextInfo(false, originAttributes); + + nsresult rv = mCacheStorageService->DiskCacheStorage( + lci, false, getter_AddRefs(cacheDiskStorage)); + NS_ENSURE_SUCCESS(rv, rv); + + uint32_t openFlags = + nsICacheStorage::OPEN_READONLY | nsICacheStorage::OPEN_SECRETLY | + nsICacheStorage::OPEN_PRIORITY | nsICacheStorage::CHECK_MULTITHREADED; + cacheDiskStorage->AsyncOpenURI(uriKey, ""_ns, openFlags, uriAction); + + // Now we do the origin-only (and therefore predictor-only) entry + nsCOMPtr<nsIURI> targetOrigin; + rv = ExtractOrigin(uriKey, getter_AddRefs(targetOrigin)); + NS_ENSURE_SUCCESS(rv, rv); + if (!originKey) { + originKey = targetOrigin; + } + + RefPtr<Predictor::Action> originAction = new Predictor::Action( + Predictor::Action::IS_ORIGIN, Predictor::Action::DO_PREDICT, argReason, + targetOrigin, nullptr, verifier, this); + nsAutoCString originKeyStr; + originKey->GetAsciiSpec(originKeyStr); + PREDICTOR_LOG((" Predict origin=%s reason=%d action=%p", + originKeyStr.get(), reason, originAction.get())); + openFlags = nsICacheStorage::OPEN_READONLY | nsICacheStorage::OPEN_SECRETLY | + nsICacheStorage::CHECK_MULTITHREADED; + cacheDiskStorage->AsyncOpenURI(originKey, + nsLiteralCString(PREDICTOR_ORIGIN_EXTENSION), + openFlags, originAction); + + PREDICTOR_LOG((" predict returning")); + return NS_OK; +} + +bool Predictor::PredictInternal(PredictorPredictReason reason, + nsICacheEntry* entry, bool isNew, bool fullUri, + nsIURI* targetURI, + nsINetworkPredictorVerifier* verifier, + uint8_t stackCount) { + MOZ_ASSERT(NS_IsMainThread()); + + PREDICTOR_LOG(("Predictor::PredictInternal")); + bool rv = false; + + nsCOMPtr<nsILoadContextInfo> lci; + entry->GetLoadContextInfo(getter_AddRefs(lci)); + + if (!lci) { + return rv; + } + + if (reason == nsINetworkPredictor::PREDICT_LOAD) { + MaybeLearnForStartup(targetURI, fullUri, *lci->OriginAttributesPtr()); + } + + if (isNew) { + // nothing else we can do here + PREDICTOR_LOG((" new entry")); + return rv; + } + + switch (reason) { + case nsINetworkPredictor::PREDICT_LOAD: + rv = PredictForPageload(entry, targetURI, stackCount, fullUri, verifier); + break; + case nsINetworkPredictor::PREDICT_STARTUP: + rv = PredictForStartup(entry, fullUri, verifier); + break; + default: + PREDICTOR_LOG((" invalid reason")); + MOZ_ASSERT(false, "Got unexpected value for prediction reason"); + } + + return rv; +} + +void Predictor::PredictForLink(nsIURI* targetURI, nsIURI* sourceURI, + const OriginAttributes& originAttributes, + nsINetworkPredictorVerifier* verifier) { + MOZ_ASSERT(NS_IsMainThread()); + + PREDICTOR_LOG(("Predictor::PredictForLink")); + if (!mSpeculativeService) { + PREDICTOR_LOG((" missing speculative service")); + return; + } + + if (!StaticPrefs::network_predictor_enable_hover_on_ssl()) { + if (sourceURI->SchemeIs("https")) { + // We don't want to predict from an HTTPS page, to avoid info leakage + PREDICTOR_LOG((" Not predicting for link hover - on an SSL page")); + return; + } + } + + nsCOMPtr<nsIPrincipal> principal = + BasePrincipal::CreateContentPrincipal(targetURI, originAttributes); + + mSpeculativeService->SpeculativeConnect(targetURI, principal, nullptr); + if (verifier) { + PREDICTOR_LOG((" sending verification")); + verifier->OnPredictPreconnect(targetURI); + } +} + +// This is the driver for prediction based on a new pageload. +static const uint8_t MAX_PAGELOAD_DEPTH = 10; +bool Predictor::PredictForPageload(nsICacheEntry* entry, nsIURI* targetURI, + uint8_t stackCount, bool fullUri, + nsINetworkPredictorVerifier* verifier) { + MOZ_ASSERT(NS_IsMainThread()); + + PREDICTOR_LOG(("Predictor::PredictForPageload")); + + if (stackCount > MAX_PAGELOAD_DEPTH) { + PREDICTOR_LOG((" exceeded recursion depth!")); + return false; + } + + uint32_t lastLoad; + nsresult rv = entry->GetLastFetched(&lastLoad); + NS_ENSURE_SUCCESS(rv, false); + + int32_t globalDegradation = CalculateGlobalDegradation(lastLoad); + PREDICTOR_LOG((" globalDegradation = %d", globalDegradation)); + + int32_t loadCount; + rv = entry->GetFetchCount(&loadCount); + NS_ENSURE_SUCCESS(rv, false); + + nsCOMPtr<nsILoadContextInfo> lci; + + rv = entry->GetLoadContextInfo(getter_AddRefs(lci)); + NS_ENSURE_SUCCESS(rv, false); + + nsCOMPtr<nsIURI> redirectURI; + if (WouldRedirect(entry, loadCount, lastLoad, globalDegradation, + getter_AddRefs(redirectURI))) { + mPreconnects.AppendElement(redirectURI); + Predictor::Reason reason; + reason.mPredict = nsINetworkPredictor::PREDICT_LOAD; + RefPtr<Predictor::Action> redirectAction = new Predictor::Action( + Predictor::Action::IS_FULL_URI, Predictor::Action::DO_PREDICT, reason, + redirectURI, nullptr, verifier, this, stackCount + 1); + nsAutoCString redirectUriString; + redirectURI->GetAsciiSpec(redirectUriString); + + nsCOMPtr<nsICacheStorage> cacheDiskStorage; + + rv = mCacheStorageService->DiskCacheStorage( + lci, false, getter_AddRefs(cacheDiskStorage)); + NS_ENSURE_SUCCESS(rv, false); + + PREDICTOR_LOG((" Predict redirect uri=%s action=%p", + redirectUriString.get(), redirectAction.get())); + uint32_t openFlags = + nsICacheStorage::OPEN_READONLY | nsICacheStorage::OPEN_SECRETLY | + nsICacheStorage::OPEN_PRIORITY | nsICacheStorage::CHECK_MULTITHREADED; + cacheDiskStorage->AsyncOpenURI(redirectURI, ""_ns, openFlags, + redirectAction); + return RunPredictions(nullptr, *lci->OriginAttributesPtr(), verifier); + } + + CalculatePredictions(entry, targetURI, lastLoad, loadCount, globalDegradation, + fullUri); + + return RunPredictions(targetURI, *lci->OriginAttributesPtr(), verifier); +} + +// This is the driver for predicting at browser startup time based on pages that +// have previously been loaded close to startup. +bool Predictor::PredictForStartup(nsICacheEntry* entry, bool fullUri, + nsINetworkPredictorVerifier* verifier) { + MOZ_ASSERT(NS_IsMainThread()); + + PREDICTOR_LOG(("Predictor::PredictForStartup")); + + nsCOMPtr<nsILoadContextInfo> lci; + + nsresult rv = entry->GetLoadContextInfo(getter_AddRefs(lci)); + NS_ENSURE_SUCCESS(rv, false); + + int32_t globalDegradation = CalculateGlobalDegradation(mLastStartupTime); + CalculatePredictions(entry, nullptr, mLastStartupTime, mStartupCount, + globalDegradation, fullUri); + return RunPredictions(nullptr, *lci->OriginAttributesPtr(), verifier); +} + +// This calculates how much to degrade our confidence in our data based on +// the last time this top-level resource was loaded. This "global degradation" +// applies to *all* subresources we have associated with the top-level +// resource. This will be in addition to any reduction in confidence we have +// associated with a particular subresource. +int32_t Predictor::CalculateGlobalDegradation(uint32_t lastLoad) { + MOZ_ASSERT(NS_IsMainThread()); + + int32_t globalDegradation; + uint32_t delta = NOW_IN_SECONDS() - lastLoad; + if (delta < ONE_DAY) { + globalDegradation = StaticPrefs::network_predictor_page_degradation_day(); + } else if (delta < ONE_WEEK) { + globalDegradation = StaticPrefs::network_predictor_page_degradation_week(); + } else if (delta < ONE_MONTH) { + globalDegradation = StaticPrefs::network_predictor_page_degradation_month(); + } else if (delta < ONE_YEAR) { + globalDegradation = StaticPrefs::network_predictor_page_degradation_year(); + } else { + globalDegradation = StaticPrefs::network_predictor_page_degradation_max(); + } + + Telemetry::Accumulate(Telemetry::PREDICTOR_GLOBAL_DEGRADATION, + globalDegradation); + return globalDegradation; +} + +// This calculates our overall confidence that a particular subresource will be +// loaded as part of a top-level load. +// @param hitCount - the number of times we have loaded this subresource as part +// of this top-level load +// @param hitsPossible - the number of times we have performed this top-level +// load +// @param lastHit - the timestamp of the last time we loaded this subresource as +// part of this top-level load +// @param lastPossible - the timestamp of the last time we performed this +// top-level load +// @param globalDegradation - the degradation for this top-level load as +// determined by CalculateGlobalDegradation +int32_t Predictor::CalculateConfidence(uint32_t hitCount, uint32_t hitsPossible, + uint32_t lastHit, uint32_t lastPossible, + int32_t globalDegradation) { + MOZ_ASSERT(NS_IsMainThread()); + + Telemetry::AutoCounter<Telemetry::PREDICTOR_PREDICTIONS_CALCULATED> + predictionsCalculated; + ++predictionsCalculated; + + if (!hitsPossible) { + return 0; + } + + int32_t baseConfidence = (hitCount * 100) / hitsPossible; + int32_t maxConfidence = 100; + int32_t confidenceDegradation = 0; + + if (lastHit < lastPossible) { + // We didn't load this subresource the last time this top-level load was + // performed, so let's not bother preconnecting (at the very least). + maxConfidence = + StaticPrefs::network_predictor_preconnect_min_confidence() - 1; + + // Now calculate how much we want to degrade our confidence based on how + // long it's been between the last time we did this top-level load and the + // last time this top-level load included this subresource. + PRTime delta = lastPossible - lastHit; + if (delta == 0) { + confidenceDegradation = 0; + } else if (delta < ONE_DAY) { + confidenceDegradation = + StaticPrefs::network_predictor_subresource_degradation_day(); + } else if (delta < ONE_WEEK) { + confidenceDegradation = + StaticPrefs::network_predictor_subresource_degradation_week(); + } else if (delta < ONE_MONTH) { + confidenceDegradation = + StaticPrefs::network_predictor_subresource_degradation_month(); + } else if (delta < ONE_YEAR) { + confidenceDegradation = + StaticPrefs::network_predictor_subresource_degradation_year(); + } else { + confidenceDegradation = + StaticPrefs::network_predictor_subresource_degradation_max(); + maxConfidence = 0; + } + } + + // Calculate our confidence and clamp it to between 0 and maxConfidence + // (<= 100) + int32_t confidence = + baseConfidence - confidenceDegradation - globalDegradation; + confidence = std::max(confidence, 0); + confidence = std::min(confidence, maxConfidence); + + Telemetry::Accumulate(Telemetry::PREDICTOR_BASE_CONFIDENCE, baseConfidence); + Telemetry::Accumulate(Telemetry::PREDICTOR_SUBRESOURCE_DEGRADATION, + confidenceDegradation); + Telemetry::Accumulate(Telemetry::PREDICTOR_CONFIDENCE, confidence); + return confidence; +} + +static void MakeMetadataEntry(const uint32_t hitCount, const uint32_t lastHit, + const uint32_t flags, nsCString& newValue) { + newValue.Truncate(); + newValue.AppendInt(METADATA_VERSION); + newValue.Append(','); + newValue.AppendInt(hitCount); + newValue.Append(','); + newValue.AppendInt(lastHit); + newValue.Append(','); + newValue.AppendInt(flags); +} + +// On every page load, the rolling window gets shifted by one bit, leaving the +// lowest bit at 0, to indicate that the subresource in question has not been +// seen on the most recent page load. If, at some point later during the page +// load, the subresource is seen again, we will then set the lowest bit to 1. +// This is how we keep track of how many of the last n pageloads (for n <= 20) a +// particular subresource has been seen. The rolling window is kept in the upper +// 20 bits of the flags element of the metadata. This saves 12 bits for regular +// old flags. +void Predictor::UpdateRollingLoadCount(nsICacheEntry* entry, + const uint32_t flags, const char* key, + const uint32_t hitCount, + const uint32_t lastHit) { + // Extract just the rolling load count from the flags, shift it to clear the + // lowest bit, and put the new value with the existing flags. + uint32_t rollingLoadCount = flags & ~kFlagsMask; + rollingLoadCount <<= 1; + uint32_t newFlags = (flags & kFlagsMask) | rollingLoadCount; + + // Finally, update the metadata on the cache entry. + nsAutoCString newValue; + MakeMetadataEntry(hitCount, lastHit, newFlags, newValue); + entry->SetMetaDataElement(key, newValue.BeginReading()); +} + +uint32_t Predictor::ClampedPrefetchRollingLoadCount() { + int32_t n = StaticPrefs::network_predictor_prefetch_rolling_load_count(); + if (n < 0) { + return 0; + } + if (n > kMaxPrefetchRollingLoadCount) { + return kMaxPrefetchRollingLoadCount; + } + return n; +} + +void Predictor::CalculatePredictions(nsICacheEntry* entry, nsIURI* referrer, + uint32_t lastLoad, uint32_t loadCount, + int32_t globalDegradation, bool fullUri) { + MOZ_ASSERT(NS_IsMainThread()); + + // Since the visitor gets called under a cache lock, all we do there is get + // copies of the keys/values we care about, and then do the real work here + entry->VisitMetaData(this); + nsTArray<nsCString> keysToOperateOn = std::move(mKeysToOperateOn), + valuesToOperateOn = std::move(mValuesToOperateOn); + + MOZ_ASSERT(keysToOperateOn.Length() == valuesToOperateOn.Length()); + for (size_t i = 0; i < keysToOperateOn.Length(); ++i) { + const char* key = keysToOperateOn[i].BeginReading(); + const char* value = valuesToOperateOn[i].BeginReading(); + + nsCString uri; + uint32_t hitCount, lastHit, flags; + if (!ParseMetaDataEntry(key, value, uri, hitCount, lastHit, flags)) { + // This failed, get rid of it so we don't waste space + entry->SetMetaDataElement(key, nullptr); + continue; + } + + int32_t confidence = CalculateConfidence(hitCount, loadCount, lastHit, + lastLoad, globalDegradation); + if (fullUri) { + UpdateRollingLoadCount(entry, flags, key, hitCount, lastHit); + } + PREDICTOR_LOG(("CalculatePredictions key=%s value=%s confidence=%d", key, + value, confidence)); + PrefetchIgnoreReason reason = PREFETCH_OK; + if (!fullUri) { + // Not full URI - don't prefetch! No sense in it! + PREDICTOR_LOG((" forcing non-cacheability - not full URI")); + if (flags & FLAG_PREFETCHABLE) { + // This only applies if we had somehow otherwise marked this + // prefetchable. + reason = NOT_FULL_URI; + } + flags &= ~FLAG_PREFETCHABLE; + } else if (!referrer) { + // No referrer means we can't prefetch, so pretend it's non-cacheable, + // no matter what. + PREDICTOR_LOG((" forcing non-cacheability - no referrer")); + if (flags & FLAG_PREFETCHABLE) { + // This only applies if we had somehow otherwise marked this + // prefetchable. + reason = NO_REFERRER; + } + flags &= ~FLAG_PREFETCHABLE; + } else { + uint32_t expectedRollingLoadCount = + (1 << ClampedPrefetchRollingLoadCount()) - 1; + expectedRollingLoadCount <<= kRollingLoadOffset; + if ((flags & expectedRollingLoadCount) != expectedRollingLoadCount) { + PREDICTOR_LOG((" forcing non-cacheability - missed a load")); + if (flags & FLAG_PREFETCHABLE) { + // This only applies if we had somehow otherwise marked this + // prefetchable. + reason = MISSED_A_LOAD; + } + flags &= ~FLAG_PREFETCHABLE; + } + } + + PREDICTOR_LOG((" setting up prediction")); + SetupPrediction(confidence, flags, uri, reason); + } +} + +// (Maybe) adds a predictive action to the prediction runner, based on our +// calculated confidence for the subresource in question. +void Predictor::SetupPrediction(int32_t confidence, uint32_t flags, + const nsCString& uri, + PrefetchIgnoreReason earlyReason) { + MOZ_ASSERT(NS_IsMainThread()); + + nsresult rv = NS_OK; + PREDICTOR_LOG( + ("SetupPrediction enable-prefetch=%d prefetch-min-confidence=%d " + "preconnect-min-confidence=%d preresolve-min-confidence=%d " + "flags=%d confidence=%d uri=%s", + StaticPrefs::network_predictor_enable_prefetch(), + StaticPrefs::network_predictor_prefetch_min_confidence(), + StaticPrefs::network_predictor_preconnect_min_confidence(), + StaticPrefs::network_predictor_preresolve_min_confidence(), flags, + confidence, uri.get())); + + bool prefetchOk = !!(flags & FLAG_PREFETCHABLE); + PrefetchIgnoreReason reason = earlyReason; + if (prefetchOk && !StaticPrefs::network_predictor_enable_prefetch()) { + prefetchOk = false; + reason = PREFETCH_DISABLED; + } else if (prefetchOk && !ClampedPrefetchRollingLoadCount() && + confidence < + StaticPrefs::network_predictor_prefetch_min_confidence()) { + prefetchOk = false; + if (!ClampedPrefetchRollingLoadCount()) { + reason = PREFETCH_DISABLED_VIA_COUNT; + } else { + reason = CONFIDENCE_TOO_LOW; + } + } + + // prefetchOk == false and reason == PREFETCH_OK indicates that the reason + // we aren't prefetching this item is because it was marked un-prefetchable in + // our metadata. We already have separate telemetry on that decision, so we + // aren't going to accumulate more here. Right now we only care about why + // something we had marked prefetchable isn't being prefetched. + if (!prefetchOk && reason != PREFETCH_OK) { + Telemetry::Accumulate(Telemetry::PREDICTOR_PREFETCH_IGNORE_REASON, reason); + } + + if (prefetchOk) { + nsCOMPtr<nsIURI> prefetchURI; + rv = NS_NewURI(getter_AddRefs(prefetchURI), uri); + if (NS_SUCCEEDED(rv)) { + mPrefetches.AppendElement(prefetchURI); + } + } else if (confidence >= + StaticPrefs::network_predictor_preconnect_min_confidence()) { + nsCOMPtr<nsIURI> preconnectURI; + rv = NS_NewURI(getter_AddRefs(preconnectURI), uri); + if (NS_SUCCEEDED(rv)) { + mPreconnects.AppendElement(preconnectURI); + } + } else if (confidence >= + StaticPrefs::network_predictor_preresolve_min_confidence()) { + nsCOMPtr<nsIURI> preresolveURI; + rv = NS_NewURI(getter_AddRefs(preresolveURI), uri); + if (NS_SUCCEEDED(rv)) { + mPreresolves.AppendElement(preresolveURI); + } + } + + if (NS_FAILED(rv)) { + PREDICTOR_LOG( + (" NS_NewURI returned 0x%" PRIx32, static_cast<uint32_t>(rv))); + } +} + +nsresult Predictor::Prefetch(nsIURI* uri, nsIURI* referrer, + const OriginAttributes& originAttributes, + nsINetworkPredictorVerifier* verifier) { + nsAutoCString strUri, strReferrer; + uri->GetAsciiSpec(strUri); + referrer->GetAsciiSpec(strReferrer); + PREDICTOR_LOG(("Predictor::Prefetch uri=%s referrer=%s verifier=%p", + strUri.get(), strReferrer.get(), verifier)); + nsCOMPtr<nsIChannel> channel; + nsresult rv = NS_NewChannel( + getter_AddRefs(channel), uri, nsContentUtils::GetSystemPrincipal(), + nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL, + nsIContentPolicy::TYPE_OTHER, nullptr, /* nsICookieJarSettings */ + nullptr, /* aPerformanceStorage */ + nullptr, /* aLoadGroup */ + nullptr, /* aCallbacks */ + nsIRequest::LOAD_BACKGROUND); + + if (NS_FAILED(rv)) { + PREDICTOR_LOG( + (" NS_NewChannel failed rv=0x%" PRIX32, static_cast<uint32_t>(rv))); + return rv; + } + + nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo(); + rv = loadInfo->SetOriginAttributes(originAttributes); + + if (NS_FAILED(rv)) { + PREDICTOR_LOG( + (" Set originAttributes into loadInfo failed rv=0x%" PRIX32, + static_cast<uint32_t>(rv))); + return rv; + } + + nsCOMPtr<nsIHttpChannel> httpChannel; + httpChannel = do_QueryInterface(channel); + if (!httpChannel) { + PREDICTOR_LOG((" Could not get HTTP Channel from new channel!")); + return NS_ERROR_UNEXPECTED; + } + + nsCOMPtr<nsIReferrerInfo> referrerInfo = new dom::ReferrerInfo(referrer); + rv = httpChannel->SetReferrerInfoWithoutClone(referrerInfo); + NS_ENSURE_SUCCESS(rv, rv); + // XXX - set a header here to indicate this is a prefetch? + + nsCOMPtr<nsIStreamListener> listener = + new PrefetchListener(verifier, uri, this); + PREDICTOR_LOG((" calling AsyncOpen listener=%p channel=%p", listener.get(), + channel.get())); + rv = channel->AsyncOpen(listener); + if (NS_FAILED(rv)) { + PREDICTOR_LOG( + (" AsyncOpen failed rv=0x%" PRIX32, static_cast<uint32_t>(rv))); + } + + return rv; +} + +// Runs predictions that have been set up. +bool Predictor::RunPredictions(nsIURI* referrer, + const OriginAttributes& originAttributes, + nsINetworkPredictorVerifier* verifier) { + MOZ_ASSERT(NS_IsMainThread(), "Running prediction off main thread"); + + PREDICTOR_LOG(("Predictor::RunPredictions")); + + bool predicted = false; + uint32_t len, i; + + nsTArray<nsCOMPtr<nsIURI>> prefetches = std::move(mPrefetches), + preconnects = std::move(mPreconnects), + preresolves = std::move(mPreresolves); + + Telemetry::AutoCounter<Telemetry::PREDICTOR_TOTAL_PREDICTIONS> + totalPredictions; + Telemetry::AutoCounter<Telemetry::PREDICTOR_TOTAL_PREFETCHES> totalPrefetches; + Telemetry::AutoCounter<Telemetry::PREDICTOR_TOTAL_PRECONNECTS> + totalPreconnects; + Telemetry::AutoCounter<Telemetry::PREDICTOR_TOTAL_PRERESOLVES> + totalPreresolves; + + len = prefetches.Length(); + for (i = 0; i < len; ++i) { + PREDICTOR_LOG((" doing prefetch")); + nsCOMPtr<nsIURI> uri = prefetches[i]; + if (NS_SUCCEEDED(Prefetch(uri, referrer, originAttributes, verifier))) { + ++totalPredictions; + ++totalPrefetches; + predicted = true; + } + } + + len = preconnects.Length(); + for (i = 0; i < len; ++i) { + PREDICTOR_LOG((" doing preconnect")); + nsCOMPtr<nsIURI> uri = preconnects[i]; + ++totalPredictions; + ++totalPreconnects; + nsCOMPtr<nsIPrincipal> principal = + BasePrincipal::CreateContentPrincipal(uri, originAttributes); + mSpeculativeService->SpeculativeConnect(uri, principal, this); + predicted = true; + if (verifier) { + PREDICTOR_LOG((" sending preconnect verification")); + verifier->OnPredictPreconnect(uri); + } + } + + len = preresolves.Length(); + for (i = 0; i < len; ++i) { + nsCOMPtr<nsIURI> uri = preresolves[i]; + ++totalPredictions; + ++totalPreresolves; + nsAutoCString hostname; + uri->GetAsciiHost(hostname); + PREDICTOR_LOG((" doing preresolve %s", hostname.get())); + nsCOMPtr<nsICancelable> tmpCancelable; + mDnsService->AsyncResolveNative( + hostname, nsIDNSService::RESOLVE_TYPE_DEFAULT, + (nsIDNSService::RESOLVE_PRIORITY_MEDIUM | + nsIDNSService::RESOLVE_SPECULATE), + nullptr, mDNSListener, nullptr, originAttributes, + getter_AddRefs(tmpCancelable)); + + // Fetch HTTPS RR if needed. + if (StaticPrefs::network_dns_upgrade_with_https_rr() || + StaticPrefs::network_dns_use_https_rr_as_altsvc()) { + mDnsService->AsyncResolveNative( + hostname, nsIDNSService::RESOLVE_TYPE_HTTPSSVC, + (nsIDNSService::RESOLVE_PRIORITY_MEDIUM | + nsIDNSService::RESOLVE_SPECULATE), + nullptr, mDNSListener, nullptr, originAttributes, + getter_AddRefs(tmpCancelable)); + } + + predicted = true; + if (verifier) { + PREDICTOR_LOG((" sending preresolve verification")); + verifier->OnPredictDNS(uri); + } + } + + return predicted; +} + +// Find out if a top-level page is likely to redirect. +bool Predictor::WouldRedirect(nsICacheEntry* entry, uint32_t loadCount, + uint32_t lastLoad, int32_t globalDegradation, + nsIURI** redirectURI) { + // TODO - not doing redirects for first go around + MOZ_ASSERT(NS_IsMainThread()); + + return false; +} + +NS_IMETHODIMP +Predictor::Learn(nsIURI* targetURI, nsIURI* sourceURI, + PredictorLearnReason reason, JS::HandleValue originAttributes, + JSContext* aCx) { + OriginAttributes attrs; + + if (!originAttributes.isObject() || !attrs.Init(aCx, originAttributes)) { + return NS_ERROR_INVALID_ARG; + } + + return LearnNative(targetURI, sourceURI, reason, attrs); +} + +// Called from the main thread to update the database +NS_IMETHODIMP +Predictor::LearnNative(nsIURI* targetURI, nsIURI* sourceURI, + PredictorLearnReason reason, + const OriginAttributes& originAttributes) { + MOZ_ASSERT(NS_IsMainThread(), + "Predictor interface methods must be called on the main thread"); + + PREDICTOR_LOG(("Predictor::Learn")); + + if (IsNeckoChild()) { + MOZ_DIAGNOSTIC_ASSERT(gNeckoChild); + + PREDICTOR_LOG((" called on child process")); + + RefPtr<PredictorLearnRunnable> runnable = new PredictorLearnRunnable( + targetURI, sourceURI, reason, originAttributes); + SchedulerGroup::Dispatch(TaskCategory::Other, runnable.forget()); + + return NS_OK; + } + + PREDICTOR_LOG((" called on parent process")); + + if (!mInitialized) { + PREDICTOR_LOG((" not initialized")); + return NS_OK; + } + + if (!StaticPrefs::network_predictor_enabled()) { + PREDICTOR_LOG((" not enabled")); + return NS_OK; + } + + if (originAttributes.mPrivateBrowsingId > 0) { + // Don't want to do anything in PB mode + PREDICTOR_LOG((" in PB mode")); + return NS_OK; + } + + if (!IsNullOrHttp(targetURI) || !IsNullOrHttp(sourceURI)) { + PREDICTOR_LOG((" got non-HTTP[S] URI")); + return NS_ERROR_INVALID_ARG; + } + + nsCOMPtr<nsIURI> targetOrigin; + nsCOMPtr<nsIURI> sourceOrigin; + nsCOMPtr<nsIURI> uriKey; + nsCOMPtr<nsIURI> originKey; + nsresult rv; + + switch (reason) { + case nsINetworkPredictor::LEARN_LOAD_TOPLEVEL: + if (!targetURI || sourceURI) { + PREDICTOR_LOG((" load toplevel invalid URI state")); + return NS_ERROR_INVALID_ARG; + } + rv = ExtractOrigin(targetURI, getter_AddRefs(targetOrigin)); + NS_ENSURE_SUCCESS(rv, rv); + uriKey = targetURI; + originKey = targetOrigin; + break; + case nsINetworkPredictor::LEARN_STARTUP: + if (!targetURI || sourceURI) { + PREDICTOR_LOG((" startup invalid URI state")); + return NS_ERROR_INVALID_ARG; + } + rv = ExtractOrigin(targetURI, getter_AddRefs(targetOrigin)); + NS_ENSURE_SUCCESS(rv, rv); + uriKey = mStartupURI; + originKey = mStartupURI; + break; + case nsINetworkPredictor::LEARN_LOAD_REDIRECT: + case nsINetworkPredictor::LEARN_LOAD_SUBRESOURCE: + if (!targetURI || !sourceURI) { + PREDICTOR_LOG((" redirect/subresource invalid URI state")); + return NS_ERROR_INVALID_ARG; + } + rv = ExtractOrigin(targetURI, getter_AddRefs(targetOrigin)); + NS_ENSURE_SUCCESS(rv, rv); + rv = ExtractOrigin(sourceURI, getter_AddRefs(sourceOrigin)); + NS_ENSURE_SUCCESS(rv, rv); + uriKey = sourceURI; + originKey = sourceOrigin; + break; + default: + PREDICTOR_LOG((" invalid reason")); + return NS_ERROR_INVALID_ARG; + } + + Telemetry::AutoCounter<Telemetry::PREDICTOR_LEARN_ATTEMPTS> learnAttempts; + ++learnAttempts; + + Predictor::Reason argReason; + argReason.mLearn = reason; + + // We always open the full uri (general cache) entry first, so we don't gum up + // the works waiting on predictor-only entries to open + RefPtr<Predictor::Action> uriAction = new Predictor::Action( + Predictor::Action::IS_FULL_URI, Predictor::Action::DO_LEARN, argReason, + targetURI, sourceURI, nullptr, this); + nsAutoCString uriKeyStr, targetUriStr, sourceUriStr; + uriKey->GetAsciiSpec(uriKeyStr); + targetURI->GetAsciiSpec(targetUriStr); + if (sourceURI) { + sourceURI->GetAsciiSpec(sourceUriStr); + } + PREDICTOR_LOG( + (" Learn uriKey=%s targetURI=%s sourceURI=%s reason=%d " + "action=%p", + uriKeyStr.get(), targetUriStr.get(), sourceUriStr.get(), reason, + uriAction.get())); + + nsCOMPtr<nsICacheStorage> cacheDiskStorage; + + RefPtr<LoadContextInfo> lci = new LoadContextInfo(false, originAttributes); + + rv = mCacheStorageService->DiskCacheStorage(lci, false, + getter_AddRefs(cacheDiskStorage)); + NS_ENSURE_SUCCESS(rv, rv); + + // For learning full URI things, we *always* open readonly and secretly, as we + // rely on actual pageloads to update the entry's metadata for us. + uint32_t uriOpenFlags = nsICacheStorage::OPEN_READONLY | + nsICacheStorage::OPEN_SECRETLY | + nsICacheStorage::CHECK_MULTITHREADED; + if (reason == nsINetworkPredictor::LEARN_LOAD_TOPLEVEL) { + // Learning for toplevel we want to open the full uri entry priority, since + // it's likely this entry will be used soon anyway, and we want this to be + // opened ASAP. + uriOpenFlags |= nsICacheStorage::OPEN_PRIORITY; + } + cacheDiskStorage->AsyncOpenURI(uriKey, ""_ns, uriOpenFlags, uriAction); + + // Now we open the origin-only (and therefore predictor-only) entry + RefPtr<Predictor::Action> originAction = new Predictor::Action( + Predictor::Action::IS_ORIGIN, Predictor::Action::DO_LEARN, argReason, + targetOrigin, sourceOrigin, nullptr, this); + nsAutoCString originKeyStr, targetOriginStr, sourceOriginStr; + originKey->GetAsciiSpec(originKeyStr); + targetOrigin->GetAsciiSpec(targetOriginStr); + if (sourceOrigin) { + sourceOrigin->GetAsciiSpec(sourceOriginStr); + } + PREDICTOR_LOG( + (" Learn originKey=%s targetOrigin=%s sourceOrigin=%s reason=%d " + "action=%p", + originKeyStr.get(), targetOriginStr.get(), sourceOriginStr.get(), reason, + originAction.get())); + uint32_t originOpenFlags; + if (reason == nsINetworkPredictor::LEARN_LOAD_TOPLEVEL) { + // This is the only case when we want to update the 'last used' metadata on + // the cache entry we're getting. This only applies to predictor-specific + // entries. + originOpenFlags = + nsICacheStorage::OPEN_NORMALLY | nsICacheStorage::CHECK_MULTITHREADED; + } else { + originOpenFlags = nsICacheStorage::OPEN_READONLY | + nsICacheStorage::OPEN_SECRETLY | + nsICacheStorage::CHECK_MULTITHREADED; + } + cacheDiskStorage->AsyncOpenURI(originKey, + nsLiteralCString(PREDICTOR_ORIGIN_EXTENSION), + originOpenFlags, originAction); + + PREDICTOR_LOG(("Predictor::Learn returning")); + return NS_OK; +} + +void Predictor::LearnInternal(PredictorLearnReason reason, nsICacheEntry* entry, + bool isNew, bool fullUri, nsIURI* targetURI, + nsIURI* sourceURI) { + MOZ_ASSERT(NS_IsMainThread()); + + PREDICTOR_LOG(("Predictor::LearnInternal")); + + nsCString junk; + if (!fullUri && reason == nsINetworkPredictor::LEARN_LOAD_TOPLEVEL && + NS_FAILED( + entry->GetMetaDataElement(SEEN_META_DATA, getter_Copies(junk)))) { + // This is an origin-only entry that we haven't seen before. Let's mark it + // as seen. + PREDICTOR_LOG((" marking new origin entry as seen")); + nsresult rv = entry->SetMetaDataElement(SEEN_META_DATA, "1"); + if (NS_FAILED(rv)) { + PREDICTOR_LOG((" failed to mark origin entry seen")); + return; + } + + // Need to ensure someone else can get to the entry if necessary + entry->MetaDataReady(); + return; + } + + switch (reason) { + case nsINetworkPredictor::LEARN_LOAD_TOPLEVEL: + // This case only exists to be used during tests - code outside the + // predictor tests should NEVER call Learn with LEARN_LOAD_TOPLEVEL. + // The predictor xpcshell test needs this branch, however, because we + // have no real page loads in xpcshell, and this is how we fake it up + // so that all the work that normally happens behind the scenes in a + // page load can be done for testing purposes. + if (fullUri && StaticPrefs::network_predictor_doing_tests()) { + PREDICTOR_LOG( + (" WARNING - updating rolling load count. " + "If you see this outside tests, you did it wrong")); + + // Since the visitor gets called under a cache lock, all we do there is + // get copies of the keys/values we care about, and then do the real + // work here + entry->VisitMetaData(this); + nsTArray<nsCString> keysToOperateOn = std::move(mKeysToOperateOn), + valuesToOperateOn = std::move(mValuesToOperateOn); + + MOZ_ASSERT(keysToOperateOn.Length() == valuesToOperateOn.Length()); + for (size_t i = 0; i < keysToOperateOn.Length(); ++i) { + const char* key = keysToOperateOn[i].BeginReading(); + const char* value = valuesToOperateOn[i].BeginReading(); + + nsCString uri; + uint32_t hitCount, lastHit, flags; + if (!ParseMetaDataEntry(key, value, uri, hitCount, lastHit, flags)) { + // This failed, get rid of it so we don't waste space + entry->SetMetaDataElement(key, nullptr); + continue; + } + UpdateRollingLoadCount(entry, flags, key, hitCount, lastHit); + } + } else { + PREDICTOR_LOG((" nothing to do for toplevel")); + } + break; + case nsINetworkPredictor::LEARN_LOAD_REDIRECT: + if (fullUri) { + LearnForRedirect(entry, targetURI); + } + break; + case nsINetworkPredictor::LEARN_LOAD_SUBRESOURCE: + LearnForSubresource(entry, targetURI); + break; + case nsINetworkPredictor::LEARN_STARTUP: + LearnForStartup(entry, targetURI); + break; + default: + PREDICTOR_LOG((" unexpected reason value")); + MOZ_ASSERT(false, "Got unexpected value for learn reason!"); + } +} + +NS_IMPL_ISUPPORTS(Predictor::SpaceCleaner, nsICacheEntryMetaDataVisitor) + +NS_IMETHODIMP +Predictor::SpaceCleaner::OnMetaDataElement(const char* key, const char* value) { + MOZ_ASSERT(NS_IsMainThread()); + + if (!IsURIMetadataElement(key)) { + // This isn't a bit of metadata we care about + return NS_OK; + } + + nsCString uri; + uint32_t hitCount, lastHit, flags; + bool ok = + mPredictor->ParseMetaDataEntry(key, value, uri, hitCount, lastHit, flags); + + if (!ok) { + // Couldn't parse this one, just get rid of it + nsCString nsKey; + nsKey.AssignASCII(key); + mLongKeysToDelete.AppendElement(nsKey); + return NS_OK; + } + + uint32_t uriLength = uri.Length(); + if (uriLength > StaticPrefs::network_predictor_max_uri_length()) { + // Default to getting rid of URIs that are too long and were put in before + // we had our limit on URI length, in order to free up some space. + nsCString nsKey; + nsKey.AssignASCII(key); + mLongKeysToDelete.AppendElement(nsKey); + return NS_OK; + } + + if (!mLRUKeyToDelete || lastHit < mLRUStamp) { + mLRUKeyToDelete = key; + mLRUStamp = lastHit; + } + + return NS_OK; +} + +void Predictor::SpaceCleaner::Finalize(nsICacheEntry* entry) { + MOZ_ASSERT(NS_IsMainThread()); + + if (mLRUKeyToDelete) { + entry->SetMetaDataElement(mLRUKeyToDelete, nullptr); + } + + for (size_t i = 0; i < mLongKeysToDelete.Length(); ++i) { + entry->SetMetaDataElement(mLongKeysToDelete[i].BeginReading(), nullptr); + } +} + +// Called when a subresource has been hit from a top-level load. Uses the two +// helper functions above to update the database appropriately. +void Predictor::LearnForSubresource(nsICacheEntry* entry, nsIURI* targetURI) { + MOZ_ASSERT(NS_IsMainThread()); + + PREDICTOR_LOG(("Predictor::LearnForSubresource")); + + uint32_t lastLoad; + nsresult rv = entry->GetLastFetched(&lastLoad); + NS_ENSURE_SUCCESS_VOID(rv); + + int32_t loadCount; + rv = entry->GetFetchCount(&loadCount); + NS_ENSURE_SUCCESS_VOID(rv); + + nsCString key; + key.AssignLiteral(META_DATA_PREFIX); + nsCString uri; + targetURI->GetAsciiSpec(uri); + key.Append(uri); + if (uri.Length() > StaticPrefs::network_predictor_max_uri_length()) { + // We do this to conserve space/prevent OOMs + PREDICTOR_LOG((" uri too long!")); + entry->SetMetaDataElement(key.BeginReading(), nullptr); + return; + } + + nsCString value; + rv = entry->GetMetaDataElement(key.BeginReading(), getter_Copies(value)); + + uint32_t hitCount, lastHit, flags; + bool isNewResource = + (NS_FAILED(rv) || + !ParseMetaDataEntry(key.BeginReading(), value.BeginReading(), uri, + hitCount, lastHit, flags)); + + int32_t resourceCount = 0; + if (isNewResource) { + // This is a new addition + PREDICTOR_LOG((" new resource")); + nsCString s; + rv = entry->GetMetaDataElement(RESOURCE_META_DATA, getter_Copies(s)); + if (NS_SUCCEEDED(rv)) { + resourceCount = atoi(s.BeginReading()); + } + if (resourceCount >= + StaticPrefs::network_predictor_max_resources_per_entry()) { + RefPtr<Predictor::SpaceCleaner> cleaner = + new Predictor::SpaceCleaner(this); + entry->VisitMetaData(cleaner); + cleaner->Finalize(entry); + } else { + ++resourceCount; + } + nsAutoCString count; + count.AppendInt(resourceCount); + rv = entry->SetMetaDataElement(RESOURCE_META_DATA, count.BeginReading()); + if (NS_FAILED(rv)) { + PREDICTOR_LOG((" failed to update resource count")); + return; + } + hitCount = 1; + flags = 0; + } else { + PREDICTOR_LOG((" existing resource")); + hitCount = std::min(hitCount + 1, static_cast<uint32_t>(loadCount)); + } + + // Update the rolling load count to mark this sub-resource as seen on the + // most-recent pageload so it can be eligible for prefetch (assuming all + // the other stars align). + flags |= (1 << kRollingLoadOffset); + + nsCString newValue; + MakeMetadataEntry(hitCount, lastLoad, flags, newValue); + rv = entry->SetMetaDataElement(key.BeginReading(), newValue.BeginReading()); + PREDICTOR_LOG( + (" SetMetaDataElement -> 0x%08" PRIX32, static_cast<uint32_t>(rv))); + if (NS_FAILED(rv) && isNewResource) { + // Roll back the increment to the resource count we made above. + PREDICTOR_LOG((" rolling back resource count update")); + --resourceCount; + if (resourceCount == 0) { + entry->SetMetaDataElement(RESOURCE_META_DATA, nullptr); + } else { + nsAutoCString count; + count.AppendInt(resourceCount); + entry->SetMetaDataElement(RESOURCE_META_DATA, count.BeginReading()); + } + } +} + +// This is called when a top-level loaded ended up redirecting to a different +// URI so we can keep track of that fact. +void Predictor::LearnForRedirect(nsICacheEntry* entry, nsIURI* targetURI) { + MOZ_ASSERT(NS_IsMainThread()); + + // TODO - not doing redirects for first go around + PREDICTOR_LOG(("Predictor::LearnForRedirect")); +} + +// This will add a page to our list of startup pages if it's being loaded +// before our startup window has expired. +void Predictor::MaybeLearnForStartup(nsIURI* uri, bool fullUri, + const OriginAttributes& originAttributes) { + MOZ_ASSERT(NS_IsMainThread()); + + // TODO - not doing startup for first go around + PREDICTOR_LOG(("Predictor::MaybeLearnForStartup")); +} + +// Add information about a top-level load to our list of startup pages +void Predictor::LearnForStartup(nsICacheEntry* entry, nsIURI* targetURI) { + MOZ_ASSERT(NS_IsMainThread()); + + // These actually do the same set of work, just on different entries, so we + // can pass through to get the real work done here + PREDICTOR_LOG(("Predictor::LearnForStartup")); + LearnForSubresource(entry, targetURI); +} + +bool Predictor::ParseMetaDataEntry(const char* key, const char* value, + nsCString& uri, uint32_t& hitCount, + uint32_t& lastHit, uint32_t& flags) { + MOZ_ASSERT(NS_IsMainThread()); + + PREDICTOR_LOG( + ("Predictor::ParseMetaDataEntry key=%s value=%s", key ? key : "", value)); + + const char* comma = strchr(value, ','); + if (!comma) { + PREDICTOR_LOG((" could not find first comma")); + return false; + } + + uint32_t version = static_cast<uint32_t>(atoi(value)); + PREDICTOR_LOG((" version -> %u", version)); + + if (version != METADATA_VERSION) { + PREDICTOR_LOG( + (" metadata version mismatch %u != %u", version, METADATA_VERSION)); + return false; + } + + value = comma + 1; + comma = strchr(value, ','); + if (!comma) { + PREDICTOR_LOG((" could not find second comma")); + return false; + } + + hitCount = static_cast<uint32_t>(atoi(value)); + PREDICTOR_LOG((" hitCount -> %u", hitCount)); + + value = comma + 1; + comma = strchr(value, ','); + if (!comma) { + PREDICTOR_LOG((" could not find third comma")); + return false; + } + + lastHit = static_cast<uint32_t>(atoi(value)); + PREDICTOR_LOG((" lastHit -> %u", lastHit)); + + value = comma + 1; + flags = static_cast<uint32_t>(atoi(value)); + PREDICTOR_LOG((" flags -> %u", flags)); + + if (key) { + const char* uriStart = key + (sizeof(META_DATA_PREFIX) - 1); + uri.AssignASCII(uriStart); + PREDICTOR_LOG((" uri -> %s", uriStart)); + } else { + uri.Truncate(); + } + + return true; +} + +NS_IMETHODIMP +Predictor::Reset() { + MOZ_ASSERT(NS_IsMainThread(), + "Predictor interface methods must be called on the main thread"); + + PREDICTOR_LOG(("Predictor::Reset")); + + if (IsNeckoChild()) { + MOZ_DIAGNOSTIC_ASSERT(gNeckoChild); + + PREDICTOR_LOG((" forwarding to parent process")); + gNeckoChild->SendPredReset(); + return NS_OK; + } + + PREDICTOR_LOG((" called on parent process")); + + if (!mInitialized) { + PREDICTOR_LOG((" not initialized")); + return NS_OK; + } + + if (!StaticPrefs::network_predictor_enabled()) { + PREDICTOR_LOG((" not enabled")); + return NS_OK; + } + + RefPtr<Predictor::Resetter> reset = new Predictor::Resetter(this); + PREDICTOR_LOG((" created a resetter")); + mCacheStorageService->AsyncVisitAllStorages(reset, true); + PREDICTOR_LOG((" Cache async launched, returning now")); + + return NS_OK; +} + +NS_IMPL_ISUPPORTS(Predictor::Resetter, nsICacheEntryOpenCallback, + nsICacheEntryMetaDataVisitor, nsICacheStorageVisitor); + +Predictor::Resetter::Resetter(Predictor* predictor) + : mEntriesToVisit(0), mPredictor(predictor) {} + +NS_IMETHODIMP +Predictor::Resetter::OnCacheEntryCheck(nsICacheEntry* entry, + nsIApplicationCache* appCache, + uint32_t* result) { + *result = nsICacheEntryOpenCallback::ENTRY_WANTED; + return NS_OK; +} + +NS_IMETHODIMP +Predictor::Resetter::OnCacheEntryAvailable(nsICacheEntry* entry, bool isNew, + nsIApplicationCache* appCache, + nsresult result) { + MOZ_ASSERT(NS_IsMainThread()); + + if (NS_FAILED(result)) { + // This can happen when we've tried to open an entry that doesn't exist for + // some non-reset operation, and then get reset shortly thereafter (as + // happens in some of our tests). + --mEntriesToVisit; + if (!mEntriesToVisit) { + Complete(); + } + return NS_OK; + } + + entry->VisitMetaData(this); + nsTArray<nsCString> keysToDelete = std::move(mKeysToDelete); + + for (size_t i = 0; i < keysToDelete.Length(); ++i) { + const char* key = keysToDelete[i].BeginReading(); + entry->SetMetaDataElement(key, nullptr); + } + + --mEntriesToVisit; + if (!mEntriesToVisit) { + Complete(); + } + + return NS_OK; +} + +NS_IMETHODIMP +Predictor::Resetter::OnMetaDataElement(const char* asciiKey, + const char* asciiValue) { + MOZ_ASSERT(NS_IsMainThread()); + + if (!StringBeginsWith(nsDependentCString(asciiKey), + nsLiteralCString(META_DATA_PREFIX))) { + // Not a metadata entry we care about, carry on + return NS_OK; + } + + nsCString key; + key.AssignASCII(asciiKey); + mKeysToDelete.AppendElement(key); + + return NS_OK; +} + +NS_IMETHODIMP +Predictor::Resetter::OnCacheStorageInfo(uint32_t entryCount, + uint64_t consumption, uint64_t capacity, + nsIFile* diskDirectory) { + MOZ_ASSERT(NS_IsMainThread()); + + return NS_OK; +} + +NS_IMETHODIMP +Predictor::Resetter::OnCacheEntryInfo(nsIURI* uri, const nsACString& idEnhance, + int64_t dataSize, int32_t fetchCount, + uint32_t lastModifiedTime, + uint32_t expirationTime, bool aPinned, + nsILoadContextInfo* aInfo) { + MOZ_ASSERT(NS_IsMainThread()); + + nsresult rv; + + // The predictor will only ever touch entries with no idEnhance ("") or an + // idEnhance of PREDICTOR_ORIGIN_EXTENSION, so we filter out any entries that + // don't match that to avoid doing extra work. + if (idEnhance.EqualsLiteral(PREDICTOR_ORIGIN_EXTENSION)) { + // This is an entry we own, so we can just doom it entirely + nsCOMPtr<nsICacheStorage> cacheDiskStorage; + + rv = mPredictor->mCacheStorageService->DiskCacheStorage( + aInfo, false, getter_AddRefs(cacheDiskStorage)); + + NS_ENSURE_SUCCESS(rv, rv); + cacheDiskStorage->AsyncDoomURI(uri, idEnhance, nullptr); + } else if (idEnhance.IsEmpty()) { + // This is an entry we don't own, so we have to be a little more careful and + // just get rid of our own metadata entries. Append it to an array of things + // to operate on and then do the operations later so we don't end up calling + // Complete() multiple times/too soon. + ++mEntriesToVisit; + mURIsToVisit.AppendElement(uri); + mInfosToVisit.AppendElement(aInfo); + } + + return NS_OK; +} + +NS_IMETHODIMP +Predictor::Resetter::OnCacheEntryVisitCompleted() { + MOZ_ASSERT(NS_IsMainThread()); + + nsresult rv; + + nsTArray<nsCOMPtr<nsIURI>> urisToVisit = std::move(mURIsToVisit); + + MOZ_ASSERT(mEntriesToVisit == urisToVisit.Length()); + + nsTArray<nsCOMPtr<nsILoadContextInfo>> infosToVisit = + std::move(mInfosToVisit); + + MOZ_ASSERT(mEntriesToVisit == infosToVisit.Length()); + + if (!mEntriesToVisit) { + Complete(); + return NS_OK; + } + + uint32_t entriesToVisit = urisToVisit.Length(); + for (uint32_t i = 0; i < entriesToVisit; ++i) { + nsCString u; + nsCOMPtr<nsICacheStorage> cacheDiskStorage; + + rv = mPredictor->mCacheStorageService->DiskCacheStorage( + infosToVisit[i], false, getter_AddRefs(cacheDiskStorage)); + NS_ENSURE_SUCCESS(rv, rv); + + urisToVisit[i]->GetAsciiSpec(u); + cacheDiskStorage->AsyncOpenURI(urisToVisit[i], ""_ns, + nsICacheStorage::OPEN_READONLY | + nsICacheStorage::OPEN_SECRETLY | + nsICacheStorage::CHECK_MULTITHREADED, + this); + } + + return NS_OK; +} + +void Predictor::Resetter::Complete() { + MOZ_ASSERT(NS_IsMainThread()); + + nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); + if (!obs) { + PREDICTOR_LOG(("COULD NOT GET OBSERVER SERVICE!")); + return; + } + + obs->NotifyObservers(nullptr, "predictor-reset-complete", nullptr); +} + +// Helper functions to make using the predictor easier from native code + +static StaticRefPtr<nsINetworkPredictor> sPredictor; + +static nsresult EnsureGlobalPredictor(nsINetworkPredictor** aPredictor) { + MOZ_ASSERT(NS_IsMainThread()); + + if (!sPredictor) { + nsresult rv; + nsCOMPtr<nsINetworkPredictor> predictor = + do_GetService("@mozilla.org/network/predictor;1", &rv); + NS_ENSURE_SUCCESS(rv, rv); + sPredictor = predictor; + ClearOnShutdown(&sPredictor); + } + + nsCOMPtr<nsINetworkPredictor> predictor = sPredictor.get(); + predictor.forget(aPredictor); + return NS_OK; +} + +nsresult PredictorPredict(nsIURI* targetURI, nsIURI* sourceURI, + PredictorPredictReason reason, + const OriginAttributes& originAttributes, + nsINetworkPredictorVerifier* verifier) { + MOZ_ASSERT(NS_IsMainThread()); + + if (!IsNullOrHttp(targetURI) || !IsNullOrHttp(sourceURI)) { + return NS_OK; + } + + nsCOMPtr<nsINetworkPredictor> predictor; + nsresult rv = EnsureGlobalPredictor(getter_AddRefs(predictor)); + NS_ENSURE_SUCCESS(rv, rv); + + return predictor->PredictNative(targetURI, sourceURI, reason, + originAttributes, verifier); +} + +nsresult PredictorLearn(nsIURI* targetURI, nsIURI* sourceURI, + PredictorLearnReason reason, + const OriginAttributes& originAttributes) { + MOZ_ASSERT(NS_IsMainThread()); + + if (!IsNullOrHttp(targetURI) || !IsNullOrHttp(sourceURI)) { + return NS_OK; + } + + nsCOMPtr<nsINetworkPredictor> predictor; + nsresult rv = EnsureGlobalPredictor(getter_AddRefs(predictor)); + NS_ENSURE_SUCCESS(rv, rv); + + return predictor->LearnNative(targetURI, sourceURI, reason, originAttributes); +} + +nsresult PredictorLearn(nsIURI* targetURI, nsIURI* sourceURI, + PredictorLearnReason reason, nsILoadGroup* loadGroup) { + MOZ_ASSERT(NS_IsMainThread()); + + if (!IsNullOrHttp(targetURI) || !IsNullOrHttp(sourceURI)) { + return NS_OK; + } + + nsCOMPtr<nsINetworkPredictor> predictor; + nsresult rv = EnsureGlobalPredictor(getter_AddRefs(predictor)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsILoadContext> loadContext; + OriginAttributes originAttributes; + + if (loadGroup) { + nsCOMPtr<nsIInterfaceRequestor> callbacks; + loadGroup->GetNotificationCallbacks(getter_AddRefs(callbacks)); + if (callbacks) { + loadContext = do_GetInterface(callbacks); + + if (loadContext) { + loadContext->GetOriginAttributes(originAttributes); + } + } + } + + return predictor->LearnNative(targetURI, sourceURI, reason, originAttributes); +} + +nsresult PredictorLearn(nsIURI* targetURI, nsIURI* sourceURI, + PredictorLearnReason reason, dom::Document* document) { + MOZ_ASSERT(NS_IsMainThread()); + + if (!IsNullOrHttp(targetURI) || !IsNullOrHttp(sourceURI)) { + return NS_OK; + } + + nsCOMPtr<nsINetworkPredictor> predictor; + nsresult rv = EnsureGlobalPredictor(getter_AddRefs(predictor)); + NS_ENSURE_SUCCESS(rv, rv); + + OriginAttributes originAttributes; + + if (document) { + nsCOMPtr<nsIPrincipal> docPrincipal = document->NodePrincipal(); + + if (docPrincipal) { + originAttributes = docPrincipal->OriginAttributesRef(); + } + } + + return predictor->LearnNative(targetURI, sourceURI, reason, originAttributes); +} + +nsresult PredictorLearnRedirect(nsIURI* targetURI, nsIChannel* channel, + const OriginAttributes& originAttributes) { + MOZ_ASSERT(NS_IsMainThread()); + + nsCOMPtr<nsIURI> sourceURI; + nsresult rv = channel->GetOriginalURI(getter_AddRefs(sourceURI)); + NS_ENSURE_SUCCESS(rv, rv); + + bool sameUri; + rv = targetURI->Equals(sourceURI, &sameUri); + NS_ENSURE_SUCCESS(rv, rv); + + if (sameUri) { + return NS_OK; + } + + if (!IsNullOrHttp(targetURI) || !IsNullOrHttp(sourceURI)) { + return NS_OK; + } + + nsCOMPtr<nsINetworkPredictor> predictor; + rv = EnsureGlobalPredictor(getter_AddRefs(predictor)); + NS_ENSURE_SUCCESS(rv, rv); + + return predictor->LearnNative(targetURI, sourceURI, + nsINetworkPredictor::LEARN_LOAD_REDIRECT, + originAttributes); +} + +// nsINetworkPredictorVerifier + +/** + * Call through to the child's verifier (only during tests) + */ +NS_IMETHODIMP +Predictor::OnPredictPrefetch(nsIURI* aURI, uint32_t httpStatus) { + if (IsNeckoChild()) { + if (mChildVerifier) { + // Ideally, we'd assert here. But since we're slowly moving towards a + // world where we have multiple child processes, and only one child + // process will be likely to have a verifier, we have to play it safer. + return mChildVerifier->OnPredictPrefetch(aURI, httpStatus); + } + return NS_OK; + } + + MOZ_DIAGNOSTIC_ASSERT(aURI, "aURI must not be null"); + + for (auto* cp : dom::ContentParent::AllProcesses(dom::ContentParent::eLive)) { + PNeckoParent* neckoParent = SingleManagedOrNull(cp->ManagedPNeckoParent()); + if (!neckoParent) { + continue; + } + if (!neckoParent->SendPredOnPredictPrefetch(aURI, httpStatus)) { + return NS_ERROR_NOT_AVAILABLE; + } + } + + return NS_OK; +} + +NS_IMETHODIMP +Predictor::OnPredictPreconnect(nsIURI* aURI) { + if (IsNeckoChild()) { + if (mChildVerifier) { + // Ideally, we'd assert here. But since we're slowly moving towards a + // world where we have multiple child processes, and only one child + // process will be likely to have a verifier, we have to play it safer. + return mChildVerifier->OnPredictPreconnect(aURI); + } + return NS_OK; + } + + MOZ_DIAGNOSTIC_ASSERT(aURI, "aURI must not be null"); + + for (auto* cp : dom::ContentParent::AllProcesses(dom::ContentParent::eLive)) { + PNeckoParent* neckoParent = SingleManagedOrNull(cp->ManagedPNeckoParent()); + if (!neckoParent) { + continue; + } + if (!neckoParent->SendPredOnPredictPreconnect(aURI)) { + return NS_ERROR_NOT_AVAILABLE; + } + } + + return NS_OK; +} + +NS_IMETHODIMP +Predictor::OnPredictDNS(nsIURI* aURI) { + if (IsNeckoChild()) { + if (mChildVerifier) { + // Ideally, we'd assert here. But since we're slowly moving towards a + // world where we have multiple child processes, and only one child + // process will be likely to have a verifier, we have to play it safer. + return mChildVerifier->OnPredictDNS(aURI); + } + return NS_OK; + } + + MOZ_DIAGNOSTIC_ASSERT(aURI, "aURI must not be null"); + + for (auto* cp : dom::ContentParent::AllProcesses(dom::ContentParent::eLive)) { + PNeckoParent* neckoParent = SingleManagedOrNull(cp->ManagedPNeckoParent()); + if (!neckoParent) { + continue; + } + if (!neckoParent->SendPredOnPredictDNS(aURI)) { + return NS_ERROR_NOT_AVAILABLE; + } + } + + return NS_OK; +} + +// Predictor::PrefetchListener +// nsISupports +NS_IMPL_ISUPPORTS(Predictor::PrefetchListener, nsIStreamListener, + nsIRequestObserver) + +// nsIRequestObserver +NS_IMETHODIMP +Predictor::PrefetchListener::OnStartRequest(nsIRequest* aRequest) { + mStartTime = TimeStamp::Now(); + return NS_OK; +} + +NS_IMETHODIMP +Predictor::PrefetchListener::OnStopRequest(nsIRequest* aRequest, + nsresult aStatusCode) { + PREDICTOR_LOG(("OnStopRequest this=%p aStatusCode=0x%" PRIX32, this, + static_cast<uint32_t>(aStatusCode))); + NS_ENSURE_ARG(aRequest); + if (NS_FAILED(aStatusCode)) { + return aStatusCode; + } + Telemetry::AccumulateTimeDelta(Telemetry::PREDICTOR_PREFETCH_TIME, + mStartTime); + + nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aRequest); + if (!httpChannel) { + PREDICTOR_LOG((" Could not get HTTP Channel!")); + return NS_ERROR_UNEXPECTED; + } + nsCOMPtr<nsICachingChannel> cachingChannel = do_QueryInterface(httpChannel); + if (!cachingChannel) { + PREDICTOR_LOG((" Could not get caching channel!")); + return NS_ERROR_UNEXPECTED; + } + + nsresult rv = NS_OK; + uint32_t httpStatus; + rv = httpChannel->GetResponseStatus(&httpStatus); + if (NS_SUCCEEDED(rv) && httpStatus == 200) { + rv = cachingChannel->ForceCacheEntryValidFor( + StaticPrefs::network_predictor_prefetch_force_valid_for()); + PREDICTOR_LOG((" forcing entry valid for %d seconds rv=%" PRIX32, + StaticPrefs::network_predictor_prefetch_force_valid_for(), + static_cast<uint32_t>(rv))); + } else { + rv = cachingChannel->ForceCacheEntryValidFor(0); + PREDICTOR_LOG((" removing any forced validity rv=%" PRIX32, + static_cast<uint32_t>(rv))); + } + + nsAutoCString reqName; + rv = aRequest->GetName(reqName); + if (NS_FAILED(rv)) { + reqName.AssignLiteral("<unknown>"); + } + + PREDICTOR_LOG((" request %s status %u", reqName.get(), httpStatus)); + + if (mVerifier) { + mVerifier->OnPredictPrefetch(mURI, httpStatus); + } + + return rv; +} + +// nsIStreamListener +NS_IMETHODIMP +Predictor::PrefetchListener::OnDataAvailable(nsIRequest* aRequest, + nsIInputStream* aInputStream, + uint64_t aOffset, + const uint32_t aCount) { + uint32_t result; + return aInputStream->ReadSegments(NS_DiscardSegment, nullptr, aCount, + &result); +} + +// Miscellaneous Predictor + +void Predictor::UpdateCacheability(nsIURI* sourceURI, nsIURI* targetURI, + uint32_t httpStatus, + nsHttpRequestHead& requestHead, + nsHttpResponseHead* responseHead, + nsILoadContextInfo* lci, bool isTracking) { + MOZ_ASSERT(NS_IsMainThread()); + + if (lci && lci->IsPrivate()) { + PREDICTOR_LOG(("Predictor::UpdateCacheability in PB mode - ignoring")); + return; + } + + if (!sourceURI || !targetURI) { + PREDICTOR_LOG( + ("Predictor::UpdateCacheability missing source or target uri")); + return; + } + + if (!IsNullOrHttp(sourceURI) || !IsNullOrHttp(targetURI)) { + PREDICTOR_LOG(("Predictor::UpdateCacheability non-http(s) uri")); + return; + } + + RefPtr<Predictor> self = sSelf; + if (self) { + nsAutoCString method; + requestHead.Method(method); + + nsAutoCString vary; + Unused << responseHead->GetHeader(nsHttp::Vary, vary); + + nsAutoCString cacheControlHeader; + Unused << responseHead->GetHeader(nsHttp::Cache_Control, + cacheControlHeader); + CacheControlParser cacheControl(cacheControlHeader); + + self->UpdateCacheabilityInternal(sourceURI, targetURI, httpStatus, method, + *lci->OriginAttributesPtr(), isTracking, + !vary.IsEmpty(), cacheControl.NoStore()); + } +} + +void Predictor::UpdateCacheabilityInternal( + nsIURI* sourceURI, nsIURI* targetURI, uint32_t httpStatus, + const nsCString& method, const OriginAttributes& originAttributes, + bool isTracking, bool couldVary, bool isNoStore) { + PREDICTOR_LOG(("Predictor::UpdateCacheability httpStatus=%u", httpStatus)); + + nsresult rv; + + if (!mInitialized) { + PREDICTOR_LOG((" not initialized")); + return; + } + + if (!StaticPrefs::network_predictor_enabled()) { + PREDICTOR_LOG((" not enabled")); + return; + } + + nsCOMPtr<nsICacheStorage> cacheDiskStorage; + + RefPtr<LoadContextInfo> lci = new LoadContextInfo(false, originAttributes); + + rv = mCacheStorageService->DiskCacheStorage(lci, false, + getter_AddRefs(cacheDiskStorage)); + if (NS_FAILED(rv)) { + PREDICTOR_LOG((" cannot get disk cache storage")); + return; + } + + uint32_t openFlags = nsICacheStorage::OPEN_READONLY | + nsICacheStorage::OPEN_SECRETLY | + nsICacheStorage::CHECK_MULTITHREADED; + RefPtr<Predictor::CacheabilityAction> action = + new Predictor::CacheabilityAction(targetURI, httpStatus, method, + isTracking, couldVary, isNoStore, this); + nsAutoCString uri; + targetURI->GetAsciiSpec(uri); + PREDICTOR_LOG((" uri=%s action=%p", uri.get(), action.get())); + cacheDiskStorage->AsyncOpenURI(sourceURI, ""_ns, openFlags, action); +} + +NS_IMPL_ISUPPORTS(Predictor::CacheabilityAction, nsICacheEntryOpenCallback, + nsICacheEntryMetaDataVisitor); + +NS_IMETHODIMP +Predictor::CacheabilityAction::OnCacheEntryCheck(nsICacheEntry* entry, + nsIApplicationCache* appCache, + uint32_t* result) { + *result = nsICacheEntryOpenCallback::ENTRY_WANTED; + return NS_OK; +} + +namespace { +enum PrefetchDecisionReason { + PREFETCHABLE, + STATUS_NOT_200, + METHOD_NOT_GET, + URL_HAS_QUERY_STRING, + RESOURCE_IS_TRACKING, + RESOURCE_COULD_VARY, + RESOURCE_IS_NO_STORE +}; +} + +NS_IMETHODIMP +Predictor::CacheabilityAction::OnCacheEntryAvailable( + nsICacheEntry* entry, bool isNew, nsIApplicationCache* appCache, + nsresult result) { + MOZ_ASSERT(NS_IsMainThread()); + // This is being opened read-only, so isNew should always be false + MOZ_ASSERT(!isNew); + + PREDICTOR_LOG(("CacheabilityAction::OnCacheEntryAvailable this=%p", this)); + if (NS_FAILED(result)) { + // Nothing to do + PREDICTOR_LOG((" nothing to do result=%" PRIX32 " isNew=%d", + static_cast<uint32_t>(result), isNew)); + return NS_OK; + } + + nsCString strTargetURI; + nsresult rv = mTargetURI->GetAsciiSpec(strTargetURI); + if (NS_FAILED(rv)) { + PREDICTOR_LOG( + (" GetAsciiSpec returned %" PRIx32, static_cast<uint32_t>(rv))); + return NS_OK; + } + + rv = entry->VisitMetaData(this); + if (NS_FAILED(rv)) { + PREDICTOR_LOG( + (" VisitMetaData returned %" PRIx32, static_cast<uint32_t>(rv))); + return NS_OK; + } + + nsTArray<nsCString> keysToCheck = std::move(mKeysToCheck), + valuesToCheck = std::move(mValuesToCheck); + + bool hasQueryString = false; + nsAutoCString query; + if (NS_SUCCEEDED(mTargetURI->GetQuery(query)) && !query.IsEmpty()) { + hasQueryString = true; + } + + MOZ_ASSERT(keysToCheck.Length() == valuesToCheck.Length()); + for (size_t i = 0; i < keysToCheck.Length(); ++i) { + const char* key = keysToCheck[i].BeginReading(); + const char* value = valuesToCheck[i].BeginReading(); + nsCString uri; + uint32_t hitCount, lastHit, flags; + + if (!mPredictor->ParseMetaDataEntry(key, value, uri, hitCount, lastHit, + flags)) { + PREDICTOR_LOG((" failed to parse key=%s value=%s", key, value)); + continue; + } + + if (strTargetURI.Equals(uri)) { + bool prefetchable = true; + PrefetchDecisionReason reason = PREFETCHABLE; + + if (mHttpStatus != 200) { + prefetchable = false; + reason = STATUS_NOT_200; + } else if (!mMethod.EqualsLiteral("GET")) { + prefetchable = false; + reason = METHOD_NOT_GET; + } else if (hasQueryString) { + prefetchable = false; + reason = URL_HAS_QUERY_STRING; + } else if (mIsTracking) { + prefetchable = false; + reason = RESOURCE_IS_TRACKING; + } else if (mCouldVary) { + prefetchable = false; + reason = RESOURCE_COULD_VARY; + } else if (mIsNoStore) { + // We don't set prefetchable = false yet, because we just want to know + // what kind of effect this would have on prefetching. + reason = RESOURCE_IS_NO_STORE; + } + + Telemetry::Accumulate(Telemetry::PREDICTOR_PREFETCH_DECISION_REASON, + reason); + + if (prefetchable) { + PREDICTOR_LOG((" marking %s cacheable", key)); + flags |= FLAG_PREFETCHABLE; + } else { + PREDICTOR_LOG((" marking %s uncacheable", key)); + flags &= ~FLAG_PREFETCHABLE; + } + nsCString newValue; + MakeMetadataEntry(hitCount, lastHit, flags, newValue); + entry->SetMetaDataElement(key, newValue.BeginReading()); + break; + } + } + + return NS_OK; +} + +NS_IMETHODIMP +Predictor::CacheabilityAction::OnMetaDataElement(const char* asciiKey, + const char* asciiValue) { + MOZ_ASSERT(NS_IsMainThread()); + + if (!IsURIMetadataElement(asciiKey)) { + return NS_OK; + } + + nsCString key, value; + key.AssignASCII(asciiKey); + value.AssignASCII(asciiValue); + mKeysToCheck.AppendElement(key); + mValuesToCheck.AppendElement(value); + + return NS_OK; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/Predictor.h b/netwerk/base/Predictor.h new file mode 100644 index 0000000000..5cdbba9294 --- /dev/null +++ b/netwerk/base/Predictor.h @@ -0,0 +1,458 @@ +/* vim: set ts=2 sts=2 et sw=2: */ +/* 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/. */ + +#ifndef mozilla_net_Predictor_h +#define mozilla_net_Predictor_h + +#include "nsINetworkPredictor.h" +#include "nsINetworkPredictorVerifier.h" + +#include "nsCOMPtr.h" +#include "nsICacheEntry.h" +#include "nsICacheEntryOpenCallback.h" +#include "nsICacheStorageService.h" +#include "nsICacheStorageVisitor.h" +#include "nsIDNSListener.h" +#include "nsIInterfaceRequestor.h" +#include "nsIObserver.h" +#include "nsISpeculativeConnect.h" +#include "nsIStreamListener.h" +#include "mozilla/RefPtr.h" +#include "nsString.h" +#include "nsTArray.h" + +#include "mozilla/TimeStamp.h" + +class nsICacheStorage; +class nsIDNSService; +class nsIIOService; +class nsILoadContextInfo; +class nsITimer; + +namespace mozilla { +namespace net { + +class nsHttpRequestHead; +class nsHttpResponseHead; + +class Predictor final : public nsINetworkPredictor, + public nsIObserver, + public nsISpeculativeConnectionOverrider, + public nsIInterfaceRequestor, + public nsICacheEntryMetaDataVisitor, + public nsINetworkPredictorVerifier { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSINETWORKPREDICTOR + NS_DECL_NSIOBSERVER + NS_DECL_NSISPECULATIVECONNECTIONOVERRIDER + NS_DECL_NSIINTERFACEREQUESTOR + NS_DECL_NSICACHEENTRYMETADATAVISITOR + NS_DECL_NSINETWORKPREDICTORVERIFIER + + Predictor(); + + nsresult Init(); + void Shutdown(); + static nsresult Create(nsISupports* outer, const nsIID& iid, void** result); + + // Used to update whether a particular URI was cacheable or not. + // sourceURI and targetURI are the same as the arguments to Learn + // and httpStatus is the status code we got while loading targetURI. + static void UpdateCacheability(nsIURI* sourceURI, nsIURI* targetURI, + uint32_t httpStatus, + nsHttpRequestHead& requestHead, + nsHttpResponseHead* reqponseHead, + nsILoadContextInfo* lci, bool isTracking); + + private: + virtual ~Predictor(); + + // Stores callbacks for a child process predictor (for test purposes) + nsCOMPtr<nsINetworkPredictorVerifier> mChildVerifier; + + union Reason { + PredictorLearnReason mLearn; + PredictorPredictReason mPredict; + }; + + class DNSListener : public nsIDNSListener { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIDNSLISTENER + + DNSListener() = default; + + private: + virtual ~DNSListener() = default; + }; + + class Action : public nsICacheEntryOpenCallback { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSICACHEENTRYOPENCALLBACK + + Action(bool fullUri, bool predict, Reason reason, nsIURI* targetURI, + nsIURI* sourceURI, nsINetworkPredictorVerifier* verifier, + Predictor* predictor); + Action(bool fullUri, bool predict, Reason reason, nsIURI* targetURI, + nsIURI* sourceURI, nsINetworkPredictorVerifier* verifier, + Predictor* predictor, uint8_t stackCount); + + static const bool IS_FULL_URI = true; + static const bool IS_ORIGIN = false; + + static const bool DO_PREDICT = true; + static const bool DO_LEARN = false; + + private: + virtual ~Action() = default; + + bool mFullUri : 1; + bool mPredict : 1; + union { + PredictorPredictReason mPredictReason; + PredictorLearnReason mLearnReason; + }; + nsCOMPtr<nsIURI> mTargetURI; + nsCOMPtr<nsIURI> mSourceURI; + nsCOMPtr<nsINetworkPredictorVerifier> mVerifier; + TimeStamp mStartTime; + uint8_t mStackCount; + RefPtr<Predictor> mPredictor; + }; + + class CacheabilityAction : public nsICacheEntryOpenCallback, + public nsICacheEntryMetaDataVisitor { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSICACHEENTRYOPENCALLBACK + NS_DECL_NSICACHEENTRYMETADATAVISITOR + + CacheabilityAction(nsIURI* targetURI, uint32_t httpStatus, + const nsCString& method, bool isTracking, bool couldVary, + bool isNoStore, Predictor* predictor) + : mTargetURI(targetURI), + mHttpStatus(httpStatus), + mMethod(method), + mIsTracking(isTracking), + mCouldVary(couldVary), + mIsNoStore(isNoStore), + mPredictor(predictor) {} + + private: + virtual ~CacheabilityAction() = default; + + nsCOMPtr<nsIURI> mTargetURI; + uint32_t mHttpStatus; + nsCString mMethod; + bool mIsTracking; + bool mCouldVary; + bool mIsNoStore; + RefPtr<Predictor> mPredictor; + nsTArray<nsCString> mKeysToCheck; + nsTArray<nsCString> mValuesToCheck; + }; + + class Resetter : public nsICacheEntryOpenCallback, + public nsICacheEntryMetaDataVisitor, + public nsICacheStorageVisitor { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSICACHEENTRYOPENCALLBACK + NS_DECL_NSICACHEENTRYMETADATAVISITOR + NS_DECL_NSICACHESTORAGEVISITOR + + explicit Resetter(Predictor* predictor); + + private: + virtual ~Resetter() = default; + + void Complete(); + + uint32_t mEntriesToVisit; + nsTArray<nsCString> mKeysToDelete; + RefPtr<Predictor> mPredictor; + nsTArray<nsCOMPtr<nsIURI>> mURIsToVisit; + nsTArray<nsCOMPtr<nsILoadContextInfo>> mInfosToVisit; + }; + + class SpaceCleaner : public nsICacheEntryMetaDataVisitor { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSICACHEENTRYMETADATAVISITOR + + explicit SpaceCleaner(Predictor* predictor) + : mLRUStamp(0), mLRUKeyToDelete(nullptr), mPredictor(predictor) {} + + void Finalize(nsICacheEntry* entry); + + private: + virtual ~SpaceCleaner() = default; + uint32_t mLRUStamp; + const char* mLRUKeyToDelete; + nsTArray<nsCString> mLongKeysToDelete; + RefPtr<Predictor> mPredictor; + }; + + class PrefetchListener : public nsIStreamListener { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIREQUESTOBSERVER + NS_DECL_NSISTREAMLISTENER + + PrefetchListener(nsINetworkPredictorVerifier* verifier, nsIURI* uri, + Predictor* predictor) + : mVerifier(verifier), mURI(uri), mPredictor(predictor) {} + + private: + virtual ~PrefetchListener() = default; + + nsCOMPtr<nsINetworkPredictorVerifier> mVerifier; + nsCOMPtr<nsIURI> mURI; + RefPtr<Predictor> mPredictor; + TimeStamp mStartTime; + }; + + // Observer-related stuff + nsresult InstallObserver(); + void RemoveObserver(); + + // Service startup utilities + void MaybeCleanupOldDBFiles(); + + // The guts of prediction + + // This is the top-level driver for doing any prediction that needs + // information from the cache. Returns true if any predictions were queued up + // * reason - What kind of prediction this is/why this prediction is + // happening (pageload, startup) + // * entry - the cache entry with the information we need + // * isNew - whether or not the cache entry is brand new and empty + // * fullUri - whether we are doing predictions based on a full page URI, or + // just the origin of the page + // * targetURI - the URI that we are predicting based upon - IOW, the URI + // that is being loaded or being redirected to + // * verifier - used for testing to verify the expected predictions happen + // * stackCount - used to ensure we don't recurse too far trying to find the + // final redirection in a redirect chain + bool PredictInternal(PredictorPredictReason reason, nsICacheEntry* entry, + bool isNew, bool fullUri, nsIURI* targetURI, + nsINetworkPredictorVerifier* verifier, + uint8_t stackCount); + + // Used when predicting because the user's mouse hovered over a link + // * targetURI - the URI target of the link + // * sourceURI - the URI of the page on which the link appears + // * originAttributes - the originAttributes for this prediction + // * verifier - used for testing to verify the expected predictions happen + void PredictForLink(nsIURI* targetURI, nsIURI* sourceURI, + const OriginAttributes& originAttributes, + nsINetworkPredictorVerifier* verifier); + + // Used when predicting because a page is being loaded (which may include + // being the target of a redirect). All arguments are the same as for + // PredictInternal. Returns true if any predictions were queued up. + bool PredictForPageload(nsICacheEntry* entry, nsIURI* targetURI, + uint8_t stackCount, bool fullUri, + nsINetworkPredictorVerifier* verifier); + + // Used when predicting pages that will be used near browser startup. All + // arguments are the same as for PredictInternal. Returns true if any + // predictions were queued up. + bool PredictForStartup(nsICacheEntry* entry, bool fullUri, + nsINetworkPredictorVerifier* verifier); + + // Utilities related to prediction + + // Used to update our rolling load count (how many of the last n loads was a + // partular resource loaded on?) + // * entry - cache entry of page we're loading + // * flags - value that contains our rolling count as the top 20 bits (but + // we may use fewer than those 20 bits for calculations) + // * key - metadata key that we will update on entry + // * hitCount - part of the metadata we need to preserve + // * lastHit - part of the metadata we need to preserve + void UpdateRollingLoadCount(nsICacheEntry* entry, const uint32_t flags, + const char* key, const uint32_t hitCount, + const uint32_t lastHit); + + // Used to calculate how much to degrade our confidence for all resources + // on a particular page, because of how long ago the most recent load of that + // page was. Returns a value between 0 (very recent most recent load) and 100 + // (very distant most recent load) + // * lastLoad - time stamp of most recent load of a page + int32_t CalculateGlobalDegradation(uint32_t lastLoad); + + // Used to calculate how confident we are that a particular resource will be + // used. Returns a value between 0 (no confidence) and 100 (very confident) + // * hitCount - number of times this resource has been seen when loading + // this page + // * hitsPossible - number of times this page has been loaded + // * lastHit - timestamp of the last time this resource was seen when + // loading this page + // * lastPossible - timestamp of the last time this page was loaded + // * globalDegradation - value calculated by CalculateGlobalDegradation for + // this page + int32_t CalculateConfidence(uint32_t hitCount, uint32_t hitsPossible, + uint32_t lastHit, uint32_t lastPossible, + int32_t globalDegradation); + + // Used to calculate all confidence values for all resources associated with a + // page. + // * entry - the cache entry with all necessary information about this page + // * referrer - the URI that we are loading (may be null) + // * lastLoad - timestamp of the last time this page was loaded + // * loadCount - number of times this page has been loaded + // * gloablDegradation - value calculated by CalculateGlobalDegradation for + // this page + // * fullUri - whether we're predicting for a full URI or origin-only + void CalculatePredictions(nsICacheEntry* entry, nsIURI* referrer, + uint32_t lastLoad, uint32_t loadCount, + int32_t globalDegradation, bool fullUri); + + enum PrefetchIgnoreReason { + PREFETCH_OK, + NOT_FULL_URI, + NO_REFERRER, + MISSED_A_LOAD, + PREFETCH_DISABLED, + PREFETCH_DISABLED_VIA_COUNT, + CONFIDENCE_TOO_LOW + }; + + // Used to prepare any necessary prediction for a resource on a page + // * confidence - value calculated by CalculateConfidence for this resource + // * flags - the flags taken from the resource + // * uri - the ascii spec of the URI of the resource + void SetupPrediction(int32_t confidence, uint32_t flags, const nsCString& uri, + PrefetchIgnoreReason reason); + + // Used to kick off a prefetch from RunPredictions if necessary + // * uri - the URI to prefetch + // * referrer - the URI of the referring page + // * originAttributes - the originAttributes of this prefetch + // * verifier - used for testing to ensure the expected prefetch happens + nsresult Prefetch(nsIURI* uri, nsIURI* referrer, + const OriginAttributes& originAttributes, + nsINetworkPredictorVerifier* verifier); + + // Used to actually perform any predictions set up via SetupPrediction. + // Returns true if any predictions were performed. + // * referrer - the URI we are predicting from + // * originAttributs - the originAttributes we are predicting from + // * verifier - used for testing to ensure the expected predictions happen + bool RunPredictions(nsIURI* referrer, + const OriginAttributes& originAttributes, + nsINetworkPredictorVerifier* verifier); + + // Used to guess whether a page will redirect to another page or not. Returns + // true if a redirection is likely. + // * entry - cache entry with all necessary information about this page + // * loadCount - number of times this page has been loaded + // * lastLoad - timestamp of the last time this page was loaded + // * globalDegradation - value calculated by CalculateGlobalDegradation for + // this page + // * redirectURI - if this returns true, the URI that is likely to be + // redirected to, otherwise null + bool WouldRedirect(nsICacheEntry* entry, uint32_t loadCount, + uint32_t lastLoad, int32_t globalDegradation, + nsIURI** redirectURI); + + // The guts of learning information + + // This is the top-level driver for doing any updating of our information in + // the cache + // * reason - why this learn is happening (pageload, startup, redirect) + // * entry - the cache entry with the information we need + // * isNew - whether or not the cache entry is brand new and empty + // * fullUri - whether we are doing predictions based on a full page URI, or + // just the origin of the page + // * targetURI - the URI that we are adding to our data - most often a + // resource loaded by a page the user navigated to + // * sourceURI - the URI that caused targetURI to be loaded, usually the + // page the user navigated to + void LearnInternal(PredictorLearnReason reason, nsICacheEntry* entry, + bool isNew, bool fullUri, nsIURI* targetURI, + nsIURI* sourceURI); + + // Used when learning about a resource loaded by a page + // * entry - the cache entry with information that needs updating + // * targetURI - the URI of the resource that was loaded by the page + void LearnForSubresource(nsICacheEntry* entry, nsIURI* targetURI); + + // Used when learning about a redirect from one page to another + // * entry - the cache entry of the page that was redirected from + // * targetURI - the URI of the redirect target + void LearnForRedirect(nsICacheEntry* entry, nsIURI* targetURI); + + // Used to learn about pages loaded close to browser startup. This results in + // LearnForStartup being called if we are, in fact, near browser startup + // * uri - the URI of a page that has been loaded (may not have been near + // browser startup) + // * fullUri - true if this is a full page uri, false if it's an origin + // * originAttributes - the originAttributes for this learning. + void MaybeLearnForStartup(nsIURI* uri, bool fullUri, + const OriginAttributes& originAttributes); + + // Used in conjunction with MaybeLearnForStartup to learn about pages loaded + // close to browser startup + // * entry - the cache entry that stores the startup page list + // * targetURI - the URI of a page that was loaded near browser startup + void LearnForStartup(nsICacheEntry* entry, nsIURI* targetURI); + + // Used to parse the data we store in cache metadata + // * key - the cache metadata key + // * value - the cache metadata value + // * uri - (out) the ascii spec of the URI this metadata entry was about + // * hitCount - (out) the number of times this URI has been seen + // * lastHit - (out) timestamp of the last time this URI was seen + // * flags - (out) flags for this metadata entry + bool ParseMetaDataEntry(const char* key, const char* value, nsCString& uri, + uint32_t& hitCount, uint32_t& lastHit, + uint32_t& flags); + + // Used to update whether a particular URI was cacheable or not. + // sourceURI and targetURI are the same as the arguments to Learn + // and httpStatus is the status code we got while loading targetURI. + void UpdateCacheabilityInternal(nsIURI* sourceURI, nsIURI* targetURI, + uint32_t httpStatus, const nsCString& method, + const OriginAttributes& originAttributes, + bool isTracking, bool couldVary, + bool isNoStore); + + // Gets the pref value and clamps it within the acceptable range. + uint32_t ClampedPrefetchRollingLoadCount(); + + // Our state + bool mInitialized; + + nsTArray<nsCString> mKeysToOperateOn; + nsTArray<nsCString> mValuesToOperateOn; + + nsCOMPtr<nsICacheStorageService> mCacheStorageService; + + nsCOMPtr<nsISpeculativeConnect> mSpeculativeService; + + nsCOMPtr<nsIURI> mStartupURI; + uint32_t mStartupTime; + uint32_t mLastStartupTime; + int32_t mStartupCount; + + nsCOMPtr<nsIDNSService> mDnsService; + + RefPtr<DNSListener> mDNSListener; + + nsTArray<nsCOMPtr<nsIURI>> mPrefetches; + nsTArray<nsCOMPtr<nsIURI>> mPreconnects; + nsTArray<nsCOMPtr<nsIURI>> mPreresolves; + + static Predictor* sSelf; +}; + +} // namespace net +} // namespace mozilla + +#endif // mozilla_net_Predictor_h diff --git a/netwerk/base/PrivateBrowsingChannel.h b/netwerk/base/PrivateBrowsingChannel.h new file mode 100644 index 0000000000..a2e224f092 --- /dev/null +++ b/netwerk/base/PrivateBrowsingChannel.h @@ -0,0 +1,118 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=4 sts=2 sw=2 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/. */ + +#ifndef mozilla_net_PrivateBrowsingChannel_h__ +#define mozilla_net_PrivateBrowsingChannel_h__ + +#include "nsIPrivateBrowsingChannel.h" +#include "nsCOMPtr.h" +#include "nsILoadGroup.h" +#include "nsILoadContext.h" +#include "nsIInterfaceRequestorUtils.h" +#include "nsIInterfaceRequestor.h" +#include "nsNetUtil.h" +#include "mozilla/Unused.h" + +namespace mozilla { +namespace net { + +template <class Channel> +class PrivateBrowsingChannel : public nsIPrivateBrowsingChannel { + public: + PrivateBrowsingChannel() + : mPrivateBrowsingOverriden(false), mPrivateBrowsing(false) {} + + NS_IMETHOD SetPrivate(bool aPrivate) override { + // Make sure that we don't have a load context + // This is a fatal error in debug builds, and a runtime error in release + // builds. + nsCOMPtr<nsILoadContext> loadContext; + NS_QueryNotificationCallbacks(static_cast<Channel*>(this), loadContext); + MOZ_ASSERT(!loadContext); + if (loadContext) { + return NS_ERROR_FAILURE; + } + + mPrivateBrowsingOverriden = true; + mPrivateBrowsing = aPrivate; + return NS_OK; + } + + NS_IMETHOD GetIsChannelPrivate(bool* aResult) override { + NS_ENSURE_ARG_POINTER(aResult); + *aResult = mPrivateBrowsing; + return NS_OK; + } + + NS_IMETHOD IsPrivateModeOverriden(bool* aValue, bool* aResult) override { + NS_ENSURE_ARG_POINTER(aValue); + NS_ENSURE_ARG_POINTER(aResult); + *aResult = mPrivateBrowsingOverriden; + if (mPrivateBrowsingOverriden) { + *aValue = mPrivateBrowsing; + } + return NS_OK; + } + + // Must be called every time the channel's callbacks or loadGroup is updated + void UpdatePrivateBrowsing() { + // once marked as private we never go un-private + if (mPrivateBrowsing) { + return; + } + + auto channel = static_cast<Channel*>(this); + + nsCOMPtr<nsILoadContext> loadContext; + NS_QueryNotificationCallbacks(channel, loadContext); + if (loadContext) { + mPrivateBrowsing = loadContext->UsePrivateBrowsing(); + return; + } + + nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo(); + OriginAttributes attrs = loadInfo->GetOriginAttributes(); + mPrivateBrowsing = attrs.mPrivateBrowsingId > 0; + } + + bool CanSetCallbacks(nsIInterfaceRequestor* aCallbacks) const { + // Make sure that the private bit override flag is not set. + // This is a fatal error in debug builds, and a runtime error in release + // builds. + if (!aCallbacks) { + return true; + } + nsCOMPtr<nsILoadContext> loadContext = do_GetInterface(aCallbacks); + if (!loadContext) { + return true; + } + MOZ_ASSERT(!mPrivateBrowsingOverriden); + return !mPrivateBrowsingOverriden; + } + + bool CanSetLoadGroup(nsILoadGroup* aLoadGroup) const { + // Make sure that the private bit override flag is not set. + // This is a fatal error in debug builds, and a runtime error in release + // builds. + if (!aLoadGroup) { + return true; + } + nsCOMPtr<nsIInterfaceRequestor> callbacks; + aLoadGroup->GetNotificationCallbacks(getter_AddRefs(callbacks)); + // From this point on, we just hand off the work to CanSetCallbacks, + // because the logic is exactly the same. + return CanSetCallbacks(callbacks); + } + + protected: + bool mPrivateBrowsingOverriden; + bool mPrivateBrowsing; +}; + +} // namespace net +} // namespace mozilla + +#endif diff --git a/netwerk/base/ProxyAutoConfig.cpp b/netwerk/base/ProxyAutoConfig.cpp new file mode 100644 index 0000000000..6635d89de8 --- /dev/null +++ b/netwerk/base/ProxyAutoConfig.cpp @@ -0,0 +1,1048 @@ +/* -*- 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 "ProxyAutoConfig.h" +#include "nsICancelable.h" +#include "nsIDNSListener.h" +#include "nsIDNSRecord.h" +#include "nsIDNSService.h" +#include "nsINamed.h" +#include "nsThreadUtils.h" +#include "nsIConsoleService.h" +#include "nsIURLParser.h" +#include "nsJSUtils.h" +#include "jsfriendapi.h" +#include "js/CompilationAndEvaluation.h" // JS::Compile +#include "js/ContextOptions.h" +#include "js/PropertySpec.h" +#include "js/SourceText.h" // JS::Source{Ownership,Text} +#include "js/Utility.h" +#include "js/Warnings.h" // JS::SetWarningReporter +#include "prnetdb.h" +#include "nsITimer.h" +#include "mozilla/Atomics.h" +#include "mozilla/SpinEventLoopUntil.h" +#include "mozilla/net/DNS.h" +#include "mozilla/Utf8.h" // mozilla::Utf8Unit +#include "nsServiceManagerUtils.h" +#include "nsNetCID.h" + +#if defined(XP_MACOSX) +# include "nsMacUtilsImpl.h" +#endif + +namespace mozilla { +namespace net { + +// These are some global helper symbols the PAC format requires that we provide +// that are initialized as part of the global javascript context used for PAC +// evaluations. Additionally dnsResolve(host) and myIpAddress() are supplied in +// the same context but are implemented as c++ helpers. alert(msg) is similarly +// defined. +// +// Per ProxyAutoConfig::Init, this data must be ASCII. + +static const char sAsciiPacUtils[] = + "function dnsDomainIs(host, domain) {\n" + " return (host.length >= domain.length &&\n" + " host.substring(host.length - domain.length) == domain);\n" + "}\n" + "" + "function dnsDomainLevels(host) {\n" + " return host.split('.').length - 1;\n" + "}\n" + "" + "function isValidIpAddress(ipchars) {\n" + " var matches = " + "/^(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$/.exec(ipchars);\n" + " if (matches == null) {\n" + " return false;\n" + " } else if (matches[1] > 255 || matches[2] > 255 || \n" + " matches[3] > 255 || matches[4] > 255) {\n" + " return false;\n" + " }\n" + " return true;\n" + "}\n" + "" + "function convert_addr(ipchars) {\n" + " var bytes = ipchars.split('.');\n" + " var result = ((bytes[0] & 0xff) << 24) |\n" + " ((bytes[1] & 0xff) << 16) |\n" + " ((bytes[2] & 0xff) << 8) |\n" + " (bytes[3] & 0xff);\n" + " return result;\n" + "}\n" + "" + "function isInNet(ipaddr, pattern, maskstr) {\n" + " if (!isValidIpAddress(pattern) || !isValidIpAddress(maskstr)) {\n" + " return false;\n" + " }\n" + " if (!isValidIpAddress(ipaddr)) {\n" + " ipaddr = dnsResolve(ipaddr);\n" + " if (ipaddr == null) {\n" + " return false;\n" + " }\n" + " }\n" + " var host = convert_addr(ipaddr);\n" + " var pat = convert_addr(pattern);\n" + " var mask = convert_addr(maskstr);\n" + " return ((host & mask) == (pat & mask));\n" + " \n" + "}\n" + "" + "function isPlainHostName(host) {\n" + " return (host.search('\\\\.') == -1);\n" + "}\n" + "" + "function isResolvable(host) {\n" + " var ip = dnsResolve(host);\n" + " return (ip != null);\n" + "}\n" + "" + "function localHostOrDomainIs(host, hostdom) {\n" + " return (host == hostdom) ||\n" + " (hostdom.lastIndexOf(host + '.', 0) == 0);\n" + "}\n" + "" + "function shExpMatch(url, pattern) {\n" + " pattern = pattern.replace(/\\./g, '\\\\.');\n" + " pattern = pattern.replace(/\\*/g, '.*');\n" + " pattern = pattern.replace(/\\?/g, '.');\n" + " var newRe = new RegExp('^'+pattern+'$');\n" + " return newRe.test(url);\n" + "}\n" + "" + "var wdays = {SUN: 0, MON: 1, TUE: 2, WED: 3, THU: 4, FRI: 5, SAT: 6};\n" + "var months = {JAN: 0, FEB: 1, MAR: 2, APR: 3, MAY: 4, JUN: 5, JUL: 6, " + "AUG: 7, SEP: 8, OCT: 9, NOV: 10, DEC: 11};\n" + "" + "function weekdayRange() {\n" + " function getDay(weekday) {\n" + " if (weekday in wdays) {\n" + " return wdays[weekday];\n" + " }\n" + " return -1;\n" + " }\n" + " var date = new Date();\n" + " var argc = arguments.length;\n" + " var wday;\n" + " if (argc < 1)\n" + " return false;\n" + " if (arguments[argc - 1] == 'GMT') {\n" + " argc--;\n" + " wday = date.getUTCDay();\n" + " } else {\n" + " wday = date.getDay();\n" + " }\n" + " var wd1 = getDay(arguments[0]);\n" + " var wd2 = (argc == 2) ? getDay(arguments[1]) : wd1;\n" + " return (wd1 == -1 || wd2 == -1) ? false\n" + " : (wd1 <= wd2) ? (wd1 <= wday && wday " + "<= wd2)\n" + " : (wd2 >= wday || wday " + ">= wd1);\n" + "}\n" + "" + "function dateRange() {\n" + " function getMonth(name) {\n" + " if (name in months) {\n" + " return months[name];\n" + " }\n" + " return -1;\n" + " }\n" + " var date = new Date();\n" + " var argc = arguments.length;\n" + " if (argc < 1) {\n" + " return false;\n" + " }\n" + " var isGMT = (arguments[argc - 1] == 'GMT');\n" + "\n" + " if (isGMT) {\n" + " argc--;\n" + " }\n" + " // function will work even without explict handling of this case\n" + " if (argc == 1) {\n" + " var tmp = parseInt(arguments[0]);\n" + " if (isNaN(tmp)) {\n" + " return ((isGMT ? date.getUTCMonth() : date.getMonth()) ==\n" + " getMonth(arguments[0]));\n" + " } else if (tmp < 32) {\n" + " return ((isGMT ? date.getUTCDate() : date.getDate()) == " + "tmp);\n" + " } else { \n" + " return ((isGMT ? date.getUTCFullYear() : date.getFullYear()) " + "==\n" + " tmp);\n" + " }\n" + " }\n" + " var year = date.getFullYear();\n" + " var date1, date2;\n" + " date1 = new Date(year, 0, 1, 0, 0, 0);\n" + " date2 = new Date(year, 11, 31, 23, 59, 59);\n" + " var adjustMonth = false;\n" + " for (var i = 0; i < (argc >> 1); i++) {\n" + " var tmp = parseInt(arguments[i]);\n" + " if (isNaN(tmp)) {\n" + " var mon = getMonth(arguments[i]);\n" + " date1.setMonth(mon);\n" + " } else if (tmp < 32) {\n" + " adjustMonth = (argc <= 2);\n" + " date1.setDate(tmp);\n" + " } else {\n" + " date1.setFullYear(tmp);\n" + " }\n" + " }\n" + " for (var i = (argc >> 1); i < argc; i++) {\n" + " var tmp = parseInt(arguments[i]);\n" + " if (isNaN(tmp)) {\n" + " var mon = getMonth(arguments[i]);\n" + " date2.setMonth(mon);\n" + " } else if (tmp < 32) {\n" + " date2.setDate(tmp);\n" + " } else {\n" + " date2.setFullYear(tmp);\n" + " }\n" + " }\n" + " if (adjustMonth) {\n" + " date1.setMonth(date.getMonth());\n" + " date2.setMonth(date.getMonth());\n" + " }\n" + " if (isGMT) {\n" + " var tmp = date;\n" + " tmp.setFullYear(date.getUTCFullYear());\n" + " tmp.setMonth(date.getUTCMonth());\n" + " tmp.setDate(date.getUTCDate());\n" + " tmp.setHours(date.getUTCHours());\n" + " tmp.setMinutes(date.getUTCMinutes());\n" + " tmp.setSeconds(date.getUTCSeconds());\n" + " date = tmp;\n" + " }\n" + " return (date1 <= date2) ? (date1 <= date) && (date <= date2)\n" + " : (date2 >= date) || (date >= date1);\n" + "}\n" + "" + "function timeRange() {\n" + " var argc = arguments.length;\n" + " var date = new Date();\n" + " var isGMT= false;\n" + "" + " if (argc < 1) {\n" + " return false;\n" + " }\n" + " if (arguments[argc - 1] == 'GMT') {\n" + " isGMT = true;\n" + " argc--;\n" + " }\n" + "\n" + " var hour = isGMT ? date.getUTCHours() : date.getHours();\n" + " var date1, date2;\n" + " date1 = new Date();\n" + " date2 = new Date();\n" + "\n" + " if (argc == 1) {\n" + " return (hour == arguments[0]);\n" + " } else if (argc == 2) {\n" + " return ((arguments[0] <= hour) && (hour <= arguments[1]));\n" + " } else {\n" + " switch (argc) {\n" + " case 6:\n" + " date1.setSeconds(arguments[2]);\n" + " date2.setSeconds(arguments[5]);\n" + " case 4:\n" + " var middle = argc >> 1;\n" + " date1.setHours(arguments[0]);\n" + " date1.setMinutes(arguments[1]);\n" + " date2.setHours(arguments[middle]);\n" + " date2.setMinutes(arguments[middle + 1]);\n" + " if (middle == 2) {\n" + " date2.setSeconds(59);\n" + " }\n" + " break;\n" + " default:\n" + " throw 'timeRange: bad number of arguments'\n" + " }\n" + " }\n" + "\n" + " if (isGMT) {\n" + " date.setFullYear(date.getUTCFullYear());\n" + " date.setMonth(date.getUTCMonth());\n" + " date.setDate(date.getUTCDate());\n" + " date.setHours(date.getUTCHours());\n" + " date.setMinutes(date.getUTCMinutes());\n" + " date.setSeconds(date.getUTCSeconds());\n" + " }\n" + " return (date1 <= date2) ? (date1 <= date) && (date <= date2)\n" + " : (date2 >= date) || (date >= date1);\n" + "\n" + "}\n" + ""; + +// sRunning is defined for the helper functions only while the +// Javascript engine is running and the PAC object cannot be deleted +// or reset. +static Atomic<uint32_t, Relaxed>& RunningIndex() { + static Atomic<uint32_t, Relaxed> sRunningIndex(0xdeadbeef); + return sRunningIndex; +} +static ProxyAutoConfig* GetRunning() { + MOZ_ASSERT(RunningIndex() != 0xdeadbeef); + return static_cast<ProxyAutoConfig*>(PR_GetThreadPrivate(RunningIndex())); +} + +static void SetRunning(ProxyAutoConfig* arg) { + MOZ_ASSERT(RunningIndex() != 0xdeadbeef); + PR_SetThreadPrivate(RunningIndex(), arg); +} + +// The PACResolver is used for dnsResolve() +class PACResolver final : public nsIDNSListener, + public nsITimerCallback, + public nsINamed { + public: + NS_DECL_THREADSAFE_ISUPPORTS + + explicit PACResolver(nsIEventTarget* aTarget) + : mStatus(NS_ERROR_FAILURE), + mMainThreadEventTarget(aTarget), + mMutex("PACResolver::Mutex") {} + + // nsIDNSListener + NS_IMETHOD OnLookupComplete(nsICancelable* request, nsIDNSRecord* record, + nsresult status) override { + nsCOMPtr<nsITimer> timer; + { + MutexAutoLock lock(mMutex); + timer.swap(mTimer); + mRequest = nullptr; + } + + if (timer) { + timer->Cancel(); + } + + mStatus = status; + mResponse = record; + return NS_OK; + } + + // nsITimerCallback + NS_IMETHOD Notify(nsITimer* timer) override { + nsCOMPtr<nsICancelable> request; + { + MutexAutoLock lock(mMutex); + request.swap(mRequest); + mTimer = nullptr; + } + if (request) { + request->Cancel(NS_ERROR_NET_TIMEOUT); + } + return NS_OK; + } + + // nsINamed + NS_IMETHOD GetName(nsACString& aName) override { + aName.AssignLiteral("PACResolver"); + return NS_OK; + } + + nsresult mStatus; + nsCOMPtr<nsICancelable> mRequest; + nsCOMPtr<nsIDNSRecord> mResponse; + nsCOMPtr<nsITimer> mTimer; + nsCOMPtr<nsIEventTarget> mMainThreadEventTarget; + Mutex mMutex; + + private: + ~PACResolver() = default; +}; +NS_IMPL_ISUPPORTS(PACResolver, nsIDNSListener, nsITimerCallback, nsINamed) + +static void PACLogToConsole(nsString& aMessage) { + nsCOMPtr<nsIConsoleService> consoleService = + do_GetService(NS_CONSOLESERVICE_CONTRACTID); + if (!consoleService) return; + + consoleService->LogStringMessage(aMessage.get()); +} + +// Javascript errors and warnings are logged to the main error console +static void PACLogErrorOrWarning(const nsAString& aKind, + JSErrorReport* aReport) { + nsString formattedMessage(u"PAC Execution "_ns); + formattedMessage += aKind; + formattedMessage += u": "_ns; + if (aReport->message()) + formattedMessage.Append(NS_ConvertUTF8toUTF16(aReport->message().c_str())); + formattedMessage += u" ["_ns; + formattedMessage.Append(aReport->linebuf(), aReport->linebufLength()); + formattedMessage += u"]"_ns; + PACLogToConsole(formattedMessage); +} + +static void PACWarningReporter(JSContext* aCx, JSErrorReport* aReport) { + MOZ_ASSERT(aReport); + MOZ_ASSERT(aReport->isWarning()); + + PACLogErrorOrWarning(u"Warning"_ns, aReport); +} + +class MOZ_STACK_CLASS AutoPACErrorReporter { + JSContext* mCx; + + public: + explicit AutoPACErrorReporter(JSContext* aCx) : mCx(aCx) {} + ~AutoPACErrorReporter() { + if (!JS_IsExceptionPending(mCx)) { + return; + } + JS::ExceptionStack exnStack(mCx); + if (!JS::StealPendingExceptionStack(mCx, &exnStack)) { + return; + } + + JS::ErrorReportBuilder report(mCx); + if (!report.init(mCx, exnStack, JS::ErrorReportBuilder::WithSideEffects)) { + JS_ClearPendingException(mCx); + return; + } + + PACLogErrorOrWarning(u"Error"_ns, report.report()); + } +}; + +// timeout of 0 means the normal necko timeout strategy, otherwise the dns +// request will be canceled after aTimeout milliseconds +static bool PACResolve(const nsCString& aHostName, NetAddr* aNetAddr, + unsigned int aTimeout) { + if (!GetRunning()) { + NS_WARNING("PACResolve without a running ProxyAutoConfig object"); + return false; + } + + return GetRunning()->ResolveAddress(aHostName, aNetAddr, aTimeout); +} + +ProxyAutoConfig::ProxyAutoConfig() + : mJSContext(nullptr), + mJSNeedsSetup(false), + mShutdown(true), + mIncludePath(false), + mExtraHeapSize(0) { + MOZ_COUNT_CTOR(ProxyAutoConfig); +} + +bool ProxyAutoConfig::ResolveAddress(const nsCString& aHostName, + NetAddr* aNetAddr, unsigned int aTimeout) { + nsCOMPtr<nsIDNSService> dns = do_GetService(NS_DNSSERVICE_CONTRACTID); + if (!dns) return false; + + RefPtr<PACResolver> helper = new PACResolver(mMainThreadEventTarget); + OriginAttributes attrs; + + // When the PAC script attempts to resolve a domain, we must make sure we + // don't use TRR, otherwise the TRR channel might also attempt to resolve + // a name and we'll have a deadlock. + uint32_t flags = + nsIDNSService::RESOLVE_PRIORITY_MEDIUM | + nsIDNSService::GetFlagsFromTRRMode(nsIRequest::TRR_DISABLED_MODE); + + if (NS_FAILED(dns->AsyncResolveNative( + aHostName, nsIDNSService::RESOLVE_TYPE_DEFAULT, flags, nullptr, + helper, GetCurrentEventTarget(), attrs, + getter_AddRefs(helper->mRequest)))) { + return false; + } + + if (aTimeout && helper->mRequest) { + if (!mTimer) mTimer = NS_NewTimer(); + if (mTimer) { + mTimer->SetTarget(mMainThreadEventTarget); + mTimer->InitWithCallback(helper, aTimeout, nsITimer::TYPE_ONE_SHOT); + helper->mTimer = mTimer; + } + } + + // Spin the event loop of the pac thread until lookup is complete. + // nsPACman is responsible for keeping a queue and only allowing + // one PAC execution at a time even when it is called re-entrantly. + SpinEventLoopUntil([&, helper, this]() { + if (!helper->mRequest) { + return true; + } + if (this->mShutdown) { + NS_WARNING("mShutdown set with PAC request not cancelled"); + MOZ_ASSERT(NS_FAILED(helper->mStatus)); + return true; + } + return false; + }); + + if (NS_FAILED(helper->mStatus)) { + return false; + } + + nsCOMPtr<nsIDNSAddrRecord> rec = do_QueryInterface(helper->mResponse); + if (!rec || NS_FAILED(rec->GetNextAddr(0, aNetAddr))) { + return false; + } + + return true; +} + +static bool PACResolveToString(const nsCString& aHostName, + nsCString& aDottedDecimal, + unsigned int aTimeout) { + NetAddr netAddr; + if (!PACResolve(aHostName, &netAddr, aTimeout)) return false; + + char dottedDecimal[128]; + if (!netAddr.ToStringBuffer(dottedDecimal, sizeof(dottedDecimal))) + return false; + + aDottedDecimal.Assign(dottedDecimal); + return true; +} + +// dnsResolve(host) javascript implementation +static bool PACDnsResolve(JSContext* cx, unsigned int argc, JS::Value* vp) { + JS::CallArgs args = CallArgsFromVp(argc, vp); + + if (NS_IsMainThread()) { + NS_WARNING("DNS Resolution From PAC on Main Thread. How did that happen?"); + return false; + } + + if (!args.requireAtLeast(cx, "dnsResolve", 1)) return false; + + JS::Rooted<JSString*> arg1(cx, JS::ToString(cx, args[0])); + if (!arg1) return false; + + nsAutoJSString hostName; + nsAutoCString dottedDecimal; + + if (!hostName.init(cx, arg1)) return false; + if (PACResolveToString(NS_ConvertUTF16toUTF8(hostName), dottedDecimal, 0)) { + JSString* dottedDecimalString = JS_NewStringCopyZ(cx, dottedDecimal.get()); + if (!dottedDecimalString) { + return false; + } + + args.rval().setString(dottedDecimalString); + } else { + args.rval().setNull(); + } + + return true; +} + +// myIpAddress() javascript implementation +static bool PACMyIpAddress(JSContext* cx, unsigned int argc, JS::Value* vp) { + JS::CallArgs args = JS::CallArgsFromVp(argc, vp); + + if (NS_IsMainThread()) { + NS_WARNING("DNS Resolution From PAC on Main Thread. How did that happen?"); + return false; + } + + if (!GetRunning()) { + NS_WARNING("PAC myIPAddress without a running ProxyAutoConfig object"); + return false; + } + + return GetRunning()->MyIPAddress(args); +} + +// proxyAlert(msg) javascript implementation +static bool PACProxyAlert(JSContext* cx, unsigned int argc, JS::Value* vp) { + JS::CallArgs args = CallArgsFromVp(argc, vp); + + if (!args.requireAtLeast(cx, "alert", 1)) return false; + + JS::Rooted<JSString*> arg1(cx, JS::ToString(cx, args[0])); + if (!arg1) return false; + + nsAutoJSString message; + if (!message.init(cx, arg1)) return false; + + nsAutoString alertMessage; + alertMessage.AssignLiteral(u"PAC-alert: "); + alertMessage.Append(message); + PACLogToConsole(alertMessage); + + args.rval().setUndefined(); /* return undefined */ + return true; +} + +static const JSFunctionSpec PACGlobalFunctions[] = { + JS_FN("dnsResolve", PACDnsResolve, 1, 0), + + // a global "var pacUseMultihomedDNS = true;" will change behavior + // of myIpAddress to actively use DNS + JS_FN("myIpAddress", PACMyIpAddress, 0, 0), + JS_FN("alert", PACProxyAlert, 1, 0), JS_FS_END}; + +// JSContextWrapper is a c++ object that manages the context for the JS engine +// used on the PAC thread. It is initialized and destroyed on the PAC thread. +class JSContextWrapper { + public: + static JSContextWrapper* Create(uint32_t aExtraHeapSize) { + JSContext* cx = JS_NewContext(JS::DefaultHeapMaxBytes + aExtraHeapSize); + if (NS_WARN_IF(!cx)) return nullptr; + + JS::ContextOptionsRef(cx).setDisableIon().setDisableEvalSecurityChecks(); + + JSContextWrapper* entry = new JSContextWrapper(cx); + if (NS_FAILED(entry->Init())) { + delete entry; + return nullptr; + } + + return entry; + } + + JSContext* Context() const { return mContext; } + + JSObject* Global() const { return mGlobal; } + + ~JSContextWrapper() { + mGlobal = nullptr; + + MOZ_COUNT_DTOR(JSContextWrapper); + + if (mContext) { + JS_DestroyContext(mContext); + } + } + + void SetOK() { mOK = true; } + + bool IsOK() { return mOK; } + + private: + JSContext* mContext; + JS::PersistentRooted<JSObject*> mGlobal; + bool mOK; + + static const JSClass sGlobalClass; + + explicit JSContextWrapper(JSContext* cx) + : mContext(cx), mGlobal(cx, nullptr), mOK(false) { + MOZ_COUNT_CTOR(JSContextWrapper); + } + + nsresult Init() { + /* + * Not setting this will cause JS_CHECK_RECURSION to report false + * positives + */ + JS_SetNativeStackQuota(mContext, 128 * sizeof(size_t) * 1024); + + JS::SetWarningReporter(mContext, PACWarningReporter); + + if (!JS::InitSelfHostedCode(mContext)) { + return NS_ERROR_OUT_OF_MEMORY; + } + + JS::RealmOptions options; + options.creationOptions().setNewCompartmentInSystemZone(); + options.behaviors().setClampAndJitterTime(false); + mGlobal = JS_NewGlobalObject(mContext, &sGlobalClass, nullptr, + JS::DontFireOnNewGlobalHook, options); + if (!mGlobal) { + JS_ClearPendingException(mContext); + return NS_ERROR_OUT_OF_MEMORY; + } + JS::Rooted<JSObject*> global(mContext, mGlobal); + + JSAutoRealm ar(mContext, global); + AutoPACErrorReporter aper(mContext); + if (!JS_DefineFunctions(mContext, global, PACGlobalFunctions)) { + return NS_ERROR_FAILURE; + } + + JS_FireOnNewGlobalObject(mContext, global); + + return NS_OK; + } +}; + +const JSClass JSContextWrapper::sGlobalClass = {"PACResolutionThreadGlobal", + JSCLASS_GLOBAL_FLAGS, + &JS::DefaultGlobalClassOps}; + +void ProxyAutoConfig::SetThreadLocalIndex(uint32_t index) { + RunningIndex() = index; +} + +nsresult ProxyAutoConfig::Init(const nsCString& aPACURI, + const nsCString& aPACScriptData, + bool aIncludePath, uint32_t aExtraHeapSize, + nsIEventTarget* aEventTarget) { + mShutdown = false; // Shutdown needs to be called prior to destruction + + mPACURI = aPACURI; + + // The full PAC script data is the concatenation of 1) the various functions + // exposed to PAC scripts in |sAsciiPacUtils| and 2) the user-provided PAC + // script data. Historically this was single-byte Latin-1 text (usually just + // ASCII, but bug 296163 has a real-world Latin-1 example). We now support + // UTF-8 if the full data validates as UTF-8, before falling back to Latin-1. + // (Technically this is a breaking change: intentional Latin-1 scripts that + // happen to be valid UTF-8 may have different behavior. We assume such cases + // are vanishingly rare.) + // + // Supporting both UTF-8 and Latin-1 requires that the functions exposed to + // PAC scripts be both UTF-8- and Latin-1-compatible: that is, they must be + // ASCII. + mConcatenatedPACData = sAsciiPacUtils; + mConcatenatedPACData.Append(aPACScriptData); + + mIncludePath = aIncludePath; + mExtraHeapSize = aExtraHeapSize; + mMainThreadEventTarget = aEventTarget; + + if (!GetRunning()) return SetupJS(); + + mJSNeedsSetup = true; + return NS_OK; +} + +nsresult ProxyAutoConfig::SetupJS() { + mJSNeedsSetup = false; + MOZ_ASSERT(!GetRunning(), "JIT is running"); + +#if defined(XP_MACOSX) + nsMacUtilsImpl::EnableTCSMIfAvailable(); +#endif + + delete mJSContext; + mJSContext = nullptr; + + if (mConcatenatedPACData.IsEmpty()) return NS_ERROR_FAILURE; + + NS_GetCurrentThread()->SetCanInvokeJS(true); + + mJSContext = JSContextWrapper::Create(mExtraHeapSize); + if (!mJSContext) return NS_ERROR_FAILURE; + + JSContext* cx = mJSContext->Context(); + JSAutoRealm ar(cx, mJSContext->Global()); + AutoPACErrorReporter aper(cx); + + // check if this is a data: uri so that we don't spam the js console with + // huge meaningless strings. this is not on the main thread, so it can't + // use nsIURI scheme methods + bool isDataURI = + nsDependentCSubstring(mPACURI, 0, 5).LowerCaseEqualsASCII("data:", 5); + + SetRunning(this); + + JS::Rooted<JSObject*> global(cx, mJSContext->Global()); + + auto CompilePACScript = [this](JSContext* cx) -> JSScript* { + JS::CompileOptions options(cx); + options.setSkipFilenameValidation(true); + options.setFileAndLine(this->mPACURI.get(), 1); + + // Per ProxyAutoConfig::Init, compile as UTF-8 if the full data is UTF-8, + // and otherwise inflate Latin-1 to UTF-16 and compile that. + const char* scriptData = this->mConcatenatedPACData.get(); + size_t scriptLength = this->mConcatenatedPACData.Length(); + if (mozilla::IsUtf8(mozilla::Span(scriptData, scriptLength))) { + JS::SourceText<Utf8Unit> srcBuf; + if (!srcBuf.init(cx, scriptData, scriptLength, + JS::SourceOwnership::Borrowed)) { + return nullptr; + } + + return JS::Compile(cx, options, srcBuf); + } + + // nsReadableUtils.h says that "ASCII" is a misnomer "for legacy reasons", + // and this handles not just ASCII but Latin-1 too. + NS_ConvertASCIItoUTF16 inflated(this->mConcatenatedPACData); + + JS::SourceText<char16_t> source; + if (!source.init(cx, inflated.get(), inflated.Length(), + JS::SourceOwnership::Borrowed)) { + return nullptr; + } + + return JS::Compile(cx, options, source); + }; + + JS::Rooted<JSScript*> script(cx, CompilePACScript(cx)); + if (!script || !JS_ExecuteScript(cx, script)) { + nsString alertMessage(u"PAC file failed to install from "_ns); + if (isDataURI) { + alertMessage += u"data: URI"_ns; + } else { + alertMessage += NS_ConvertUTF8toUTF16(mPACURI); + } + PACLogToConsole(alertMessage); + SetRunning(nullptr); + return NS_ERROR_FAILURE; + } + SetRunning(nullptr); + + mJSContext->SetOK(); + nsString alertMessage(u"PAC file installed from "_ns); + if (isDataURI) { + alertMessage += u"data: URI"_ns; + } else { + alertMessage += NS_ConvertUTF8toUTF16(mPACURI); + } + PACLogToConsole(alertMessage); + + // we don't need these now + mConcatenatedPACData.Truncate(); + mPACURI.Truncate(); + + return NS_OK; +} + +nsresult ProxyAutoConfig::GetProxyForURI(const nsCString& aTestURI, + const nsCString& aTestHost, + nsACString& result) { + if (mJSNeedsSetup) SetupJS(); + + if (!mJSContext || !mJSContext->IsOK()) return NS_ERROR_NOT_AVAILABLE; + + JSContext* cx = mJSContext->Context(); + JSAutoRealm ar(cx, mJSContext->Global()); + AutoPACErrorReporter aper(cx); + + // the sRunning flag keeps a new PAC file from being installed + // while the event loop is spinning on a DNS function. Don't early return. + SetRunning(this); + mRunningHost = aTestHost; + + nsresult rv = NS_ERROR_FAILURE; + nsCString clensedURI = aTestURI; + + if (!mIncludePath) { + nsCOMPtr<nsIURLParser> urlParser = + do_GetService(NS_STDURLPARSER_CONTRACTID); + int32_t pathLen = 0; + if (urlParser) { + uint32_t schemePos; + int32_t schemeLen; + uint32_t authorityPos; + int32_t authorityLen; + uint32_t pathPos; + rv = urlParser->ParseURL(aTestURI.get(), aTestURI.Length(), &schemePos, + &schemeLen, &authorityPos, &authorityLen, + &pathPos, &pathLen); + } + if (NS_SUCCEEDED(rv)) { + if (pathLen) { + // cut off the path but leave the initial slash + pathLen--; + } + aTestURI.Left(clensedURI, aTestURI.Length() - pathLen); + } + } + + JS::RootedString uriString(cx, JS_NewStringCopyZ(cx, clensedURI.get())); + JS::RootedString hostString(cx, JS_NewStringCopyZ(cx, aTestHost.get())); + + if (uriString && hostString) { + JS::RootedValueArray<2> args(cx); + args[0].setString(uriString); + args[1].setString(hostString); + + JS::Rooted<JS::Value> rval(cx); + JS::Rooted<JSObject*> global(cx, mJSContext->Global()); + bool ok = JS_CallFunctionName(cx, global, "FindProxyForURL", args, &rval); + + if (ok && rval.isString()) { + nsAutoJSString pacString; + if (pacString.init(cx, rval.toString())) { + CopyUTF16toUTF8(pacString, result); + rv = NS_OK; + } + } + } + + mRunningHost.Truncate(); + SetRunning(nullptr); + return rv; +} + +void ProxyAutoConfig::GC() { + if (!mJSContext || !mJSContext->IsOK()) return; + + JSAutoRealm ar(mJSContext->Context(), mJSContext->Global()); + JS_MaybeGC(mJSContext->Context()); +} + +ProxyAutoConfig::~ProxyAutoConfig() { + MOZ_COUNT_DTOR(ProxyAutoConfig); + MOZ_ASSERT(mShutdown, "Shutdown must be called before dtor."); + NS_ASSERTION(!mJSContext, + "~ProxyAutoConfig leaking JS context that " + "should have been deleted on pac thread"); +} + +void ProxyAutoConfig::Shutdown() { + MOZ_ASSERT(!NS_IsMainThread(), "wrong thread for shutdown"); + + if (NS_WARN_IF(GetRunning()) || mShutdown) { + return; + } + + mShutdown = true; + delete mJSContext; + mJSContext = nullptr; +} + +bool ProxyAutoConfig::SrcAddress(const NetAddr* remoteAddress, + nsCString& localAddress) { + PRFileDesc* fd; + fd = PR_OpenUDPSocket(remoteAddress->raw.family); + if (!fd) return false; + + PRNetAddr prRemoteAddress; + NetAddrToPRNetAddr(remoteAddress, &prRemoteAddress); + if (PR_Connect(fd, &prRemoteAddress, 0) != PR_SUCCESS) { + PR_Close(fd); + return false; + } + + PRNetAddr localName; + if (PR_GetSockName(fd, &localName) != PR_SUCCESS) { + PR_Close(fd); + return false; + } + + PR_Close(fd); + + char dottedDecimal[128]; + if (PR_NetAddrToString(&localName, dottedDecimal, sizeof(dottedDecimal)) != + PR_SUCCESS) + return false; + + localAddress.Assign(dottedDecimal); + + return true; +} + +// hostName is run through a dns lookup and then a udp socket is connected +// to the result. If that all works, the local IP address of the socket is +// returned to the javascript caller and |*aResult| is set to true. Otherwise +// |*aResult| is set to false. +bool ProxyAutoConfig::MyIPAddressTryHost(const nsCString& hostName, + unsigned int timeout, + const JS::CallArgs& aArgs, + bool* aResult) { + *aResult = false; + + NetAddr remoteAddress; + nsAutoCString localDottedDecimal; + JSContext* cx = mJSContext->Context(); + + if (PACResolve(hostName, &remoteAddress, timeout) && + SrcAddress(&remoteAddress, localDottedDecimal)) { + JSString* dottedDecimalString = + JS_NewStringCopyZ(cx, localDottedDecimal.get()); + if (!dottedDecimalString) { + return false; + } + + *aResult = true; + aArgs.rval().setString(dottedDecimalString); + } + return true; +} + +bool ProxyAutoConfig::MyIPAddress(const JS::CallArgs& aArgs) { + nsAutoCString remoteDottedDecimal; + nsAutoCString localDottedDecimal; + JSContext* cx = mJSContext->Context(); + JS::RootedValue v(cx); + JS::Rooted<JSObject*> global(cx, mJSContext->Global()); + + bool useMultihomedDNS = + JS_GetProperty(cx, global, "pacUseMultihomedDNS", &v) && + !v.isUndefined() && ToBoolean(v); + + // first, lookup the local address of a socket connected + // to the host of uri being resolved by the pac file. This is + // v6 safe.. but is the last step like that + bool rvalAssigned = false; + if (useMultihomedDNS) { + if (!MyIPAddressTryHost(mRunningHost, kTimeout, aArgs, &rvalAssigned) || + rvalAssigned) { + return rvalAssigned; + } + } else { + // we can still do the fancy multi homing thing if the host is a literal + PRNetAddr tempAddr; + memset(&tempAddr, 0, sizeof(PRNetAddr)); + if ((PR_StringToNetAddr(mRunningHost.get(), &tempAddr) == PR_SUCCESS) && + (!MyIPAddressTryHost(mRunningHost, kTimeout, aArgs, &rvalAssigned) || + rvalAssigned)) { + return rvalAssigned; + } + } + + // next, look for a route to a public internet address that doesn't need DNS. + // This is the google anycast dns address, but it doesn't matter if it + // remains operable (as we don't contact it) as long as the address stays + // in commonly routed IP address space. + remoteDottedDecimal.AssignLiteral("8.8.8.8"); + if (!MyIPAddressTryHost(remoteDottedDecimal, 0, aArgs, &rvalAssigned) || + rvalAssigned) { + return rvalAssigned; + } + + // finally, use the old algorithm based on the local hostname + nsAutoCString hostName; + nsCOMPtr<nsIDNSService> dns = do_GetService(NS_DNSSERVICE_CONTRACTID); + // without multihomedDNS use such a short timeout that we are basically + // just looking at the cache for raw dotted decimals + uint32_t timeout = useMultihomedDNS ? kTimeout : 1; + if (dns && NS_SUCCEEDED(dns->GetMyHostName(hostName)) && + PACResolveToString(hostName, localDottedDecimal, timeout)) { + JSString* dottedDecimalString = + JS_NewStringCopyZ(cx, localDottedDecimal.get()); + if (!dottedDecimalString) { + return false; + } + + aArgs.rval().setString(dottedDecimalString); + return true; + } + + // next try a couple RFC 1918 variants.. maybe there is a + // local route + remoteDottedDecimal.AssignLiteral("192.168.0.1"); + if (!MyIPAddressTryHost(remoteDottedDecimal, 0, aArgs, &rvalAssigned) || + rvalAssigned) { + return rvalAssigned; + } + + // more RFC 1918 + remoteDottedDecimal.AssignLiteral("10.0.0.1"); + if (!MyIPAddressTryHost(remoteDottedDecimal, 0, aArgs, &rvalAssigned) || + rvalAssigned) { + return rvalAssigned; + } + + // who knows? let's fallback to localhost + localDottedDecimal.AssignLiteral("127.0.0.1"); + JSString* dottedDecimalString = + JS_NewStringCopyZ(cx, localDottedDecimal.get()); + if (!dottedDecimalString) { + return false; + } + + aArgs.rval().setString(dottedDecimalString); + return true; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/ProxyAutoConfig.h b/netwerk/base/ProxyAutoConfig.h new file mode 100644 index 0000000000..33f7c8c85d --- /dev/null +++ b/netwerk/base/ProxyAutoConfig.h @@ -0,0 +1,107 @@ +/* -*- 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/. */ + +#ifndef ProxyAutoConfig_h__ +#define ProxyAutoConfig_h__ + +#include "nsString.h" +#include "nsCOMPtr.h" + +class nsIEventTarget; +class nsITimer; +namespace JS { +class CallArgs; +} // namespace JS + +namespace mozilla { +namespace net { + +class JSContextWrapper; +union NetAddr; + +// The ProxyAutoConfig class is meant to be created and run on a +// non main thread. It synchronously resolves PAC files by blocking that +// thread and running nested event loops. GetProxyForURI is not re-entrant. + +class ProxyAutoConfig { + public: + ProxyAutoConfig(); + ~ProxyAutoConfig(); + + nsresult Init(const nsCString& aPACURI, const nsCString& aPACScriptData, + bool aIncludePath, uint32_t aExtraHeapSize, + nsIEventTarget* aEventTarget); + void SetThreadLocalIndex(uint32_t index); + void Shutdown(); + void GC(); + bool MyIPAddress(const JS::CallArgs& aArgs); + bool ResolveAddress(const nsCString& aHostName, NetAddr* aNetAddr, + unsigned int aTimeout); + + /** + * Get the proxy string for the specified URI. The proxy string is + * given by the following: + * + * result = proxy-spec *( proxy-sep proxy-spec ) + * proxy-spec = direct-type | proxy-type LWS proxy-host [":" proxy-port] + * direct-type = "DIRECT" + * proxy-type = "PROXY" | "HTTP" | "HTTPS" | "SOCKS" | "SOCKS4" | "SOCKS5" + * proxy-sep = ";" LWS + * proxy-host = hostname | ipv4-address-literal + * proxy-port = <any 16-bit unsigned integer> + * LWS = *( SP | HT ) + * SP = <US-ASCII SP, space (32)> + * HT = <US-ASCII HT, horizontal-tab (9)> + * + * NOTE: direct-type and proxy-type are case insensitive + * NOTE: SOCKS implies SOCKS4 + * + * Examples: + * "PROXY proxy1.foo.com:8080; PROXY proxy2.foo.com:8080; DIRECT" + * "SOCKS socksproxy" + * "DIRECT" + * + * XXX add support for IPv6 address literals. + * XXX quote whatever the official standard is for PAC. + * + * @param aTestURI + * The URI as an ASCII string to test. + * @param aTestHost + * The ASCII hostname to test. + * + * @param result + * result string as defined above. + */ + nsresult GetProxyForURI(const nsCString& aTestURI, const nsCString& aTestHost, + nsACString& result); + + private: + // allow 665ms for myipaddress dns queries. That's 95th percentile. + const static unsigned int kTimeout = 665; + + // used to compile the PAC file and setup the execution context + nsresult SetupJS(); + + bool SrcAddress(const NetAddr* remoteAddress, nsCString& localAddress); + bool MyIPAddressTryHost(const nsCString& hostName, unsigned int timeout, + const JS::CallArgs& aArgs, bool* aResult); + + JSContextWrapper* mJSContext; + bool mJSNeedsSetup; + bool mShutdown; + nsCString mConcatenatedPACData; + nsCString mPACURI; + bool mIncludePath; + uint32_t mExtraHeapSize; + nsCString mRunningHost; + nsCOMPtr<nsITimer> mTimer; + nsCOMPtr<nsIEventTarget> mMainThreadEventTarget; +}; + +} // namespace net +} // namespace mozilla + +#endif // ProxyAutoConfig_h__ diff --git a/netwerk/base/RedirectChannelRegistrar.cpp b/netwerk/base/RedirectChannelRegistrar.cpp new file mode 100644 index 0000000000..44914f9c45 --- /dev/null +++ b/netwerk/base/RedirectChannelRegistrar.cpp @@ -0,0 +1,89 @@ +/* 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 "RedirectChannelRegistrar.h" +#include "mozilla/StaticPtr.h" +#include "nsThreadUtils.h" + +namespace mozilla { +namespace net { + +StaticRefPtr<RedirectChannelRegistrar> RedirectChannelRegistrar::gSingleton; + +NS_IMPL_ISUPPORTS(RedirectChannelRegistrar, nsIRedirectChannelRegistrar) + +RedirectChannelRegistrar::RedirectChannelRegistrar() + : mRealChannels(32), + mParentChannels(32), + mLock("RedirectChannelRegistrar") { + MOZ_ASSERT(!gSingleton); +} + +// static +already_AddRefed<nsIRedirectChannelRegistrar> +RedirectChannelRegistrar::GetOrCreate() { + MOZ_ASSERT(NS_IsMainThread()); + if (!gSingleton) { + gSingleton = new RedirectChannelRegistrar(); + } + return do_AddRef(gSingleton); +} + +// static +void RedirectChannelRegistrar::Shutdown() { + MOZ_ASSERT(NS_IsMainThread()); + gSingleton = nullptr; +} + +NS_IMETHODIMP +RedirectChannelRegistrar::RegisterChannel(nsIChannel* channel, uint64_t id) { + MutexAutoLock lock(mLock); + + mRealChannels.Put(id, channel); + + return NS_OK; +} + +NS_IMETHODIMP +RedirectChannelRegistrar::GetRegisteredChannel(uint64_t id, + nsIChannel** _retval) { + MutexAutoLock lock(mLock); + + if (!mRealChannels.Get(id, _retval)) return NS_ERROR_NOT_AVAILABLE; + + return NS_OK; +} + +NS_IMETHODIMP +RedirectChannelRegistrar::LinkChannels(uint64_t id, nsIParentChannel* channel, + nsIChannel** _retval) { + MutexAutoLock lock(mLock); + + if (!mRealChannels.Get(id, _retval)) return NS_ERROR_NOT_AVAILABLE; + + mParentChannels.Put(id, channel); + return NS_OK; +} + +NS_IMETHODIMP +RedirectChannelRegistrar::GetParentChannel(uint64_t id, + nsIParentChannel** _retval) { + MutexAutoLock lock(mLock); + + if (!mParentChannels.Get(id, _retval)) return NS_ERROR_NOT_AVAILABLE; + + return NS_OK; +} + +NS_IMETHODIMP +RedirectChannelRegistrar::DeregisterChannels(uint64_t id) { + MutexAutoLock lock(mLock); + + mRealChannels.Remove(id); + mParentChannels.Remove(id); + return NS_OK; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/RedirectChannelRegistrar.h b/netwerk/base/RedirectChannelRegistrar.h new file mode 100644 index 0000000000..a651e40650 --- /dev/null +++ b/netwerk/base/RedirectChannelRegistrar.h @@ -0,0 +1,50 @@ +/* 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/. */ + +#ifndef RedirectChannelRegistrar_h__ +#define RedirectChannelRegistrar_h__ + +#include "nsIRedirectChannelRegistrar.h" + +#include "nsIChannel.h" +#include "nsIParentChannel.h" +#include "nsInterfaceHashtable.h" +#include "mozilla/Attributes.h" +#include "mozilla/Mutex.h" + +namespace mozilla { +namespace net { + +class RedirectChannelRegistrar final : public nsIRedirectChannelRegistrar { + NS_DECL_ISUPPORTS + NS_DECL_NSIREDIRECTCHANNELREGISTRAR + + RedirectChannelRegistrar(); + + private: + ~RedirectChannelRegistrar() = default; + + public: + // Singleton accessor + static already_AddRefed<nsIRedirectChannelRegistrar> GetOrCreate(); + + // Cleanup the singleton instance on shutdown + static void Shutdown(); + + protected: + using ChannelHashtable = nsInterfaceHashtable<nsUint64HashKey, nsIChannel>; + using ParentChannelHashtable = + nsInterfaceHashtable<nsUint64HashKey, nsIParentChannel>; + + ChannelHashtable mRealChannels; + ParentChannelHashtable mParentChannels; + Mutex mLock; + + static StaticRefPtr<RedirectChannelRegistrar> gSingleton; +}; + +} // namespace net +} // namespace mozilla + +#endif diff --git a/netwerk/base/RequestContextService.cpp b/netwerk/base/RequestContextService.cpp new file mode 100644 index 0000000000..ae44049c60 --- /dev/null +++ b/netwerk/base/RequestContextService.cpp @@ -0,0 +1,610 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 ;*; */ +/* vim: set sw=2 ts=8 et tw=80 : */ +/* 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 "nsIDocShell.h" +#include "mozilla/dom/Document.h" +#include "nsComponentManagerUtils.h" +#include "nsIDocumentLoader.h" +#include "nsIObserverService.h" +#include "nsIXULRuntime.h" +#include "nsServiceManagerUtils.h" +#include "nsThreadUtils.h" +#include "RequestContextService.h" + +#include "mozilla/Atomics.h" +#include "mozilla/ClearOnShutdown.h" +#include "mozilla/Logging.h" +#include "mozilla/Services.h" +#include "mozilla/StaticPtr.h" +#include "mozilla/TimeStamp.h" + +#include "mozilla/net/NeckoChild.h" +#include "mozilla/net/NeckoCommon.h" +#include "mozilla/net/PSpdyPush.h" + +#include "../protocol/http/nsHttpHandler.h" + +namespace mozilla { +namespace net { + +LazyLogModule gRequestContextLog("RequestContext"); +#undef LOG +#define LOG(args) MOZ_LOG(gRequestContextLog, LogLevel::Info, args) + +static StaticRefPtr<RequestContextService> gSingleton; + +// This is used to prevent adding tail pending requests after shutdown +static bool sShutdown = false; + +// nsIRequestContext +class RequestContext final : public nsIRequestContext, public nsITimerCallback { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIREQUESTCONTEXT + NS_DECL_NSITIMERCALLBACK + + explicit RequestContext(const uint64_t id); + + private: + virtual ~RequestContext(); + + void ProcessTailQueue(nsresult aResult); + // Reschedules the timer if needed + void ScheduleUnblock(); + // Hard-reschedules the timer + void RescheduleUntailTimer(TimeStamp const& now); + + uint64_t mID; + Atomic<uint32_t> mBlockingTransactionCount; + UniquePtr<SpdyPushCache> mSpdyCache; + + typedef nsCOMPtr<nsIRequestTailUnblockCallback> PendingTailRequest; + // Number of known opened non-tailed requets + uint32_t mNonTailRequests; + // Queue of requests that have been tailed, when conditions are met + // we call each of them to unblock and drop the reference + nsTArray<PendingTailRequest> mTailQueue; + // Loosly scheduled timer, never scheduled further to the future than + // mUntailAt time + nsCOMPtr<nsITimer> mUntailTimer; + // Timestamp when the timer is expected to fire, + // always less than or equal to mUntailAt + TimeStamp mTimerScheduledAt; + // Timestamp when we want to actually untail queued requets based on + // the number of request count change in the past; iff this timestamp + // is set, we tail requests + TimeStamp mUntailAt; + + // Timestamp of the navigation start time, set to Now() in BeginLoad(). + // This is used to progressively lower the maximum delay time so that + // we can't get to a situation when a number of repetitive requests + // on the page causes forever tailing. + TimeStamp mBeginLoadTime; + + // This member is true only between DOMContentLoaded notification and + // next document load beginning for this request context. + // Top level request contexts are recycled. + bool mAfterDOMContentLoaded; +}; + +NS_IMPL_ISUPPORTS(RequestContext, nsIRequestContext, nsITimerCallback) + +RequestContext::RequestContext(const uint64_t aID) + : mID(aID), + mBlockingTransactionCount(0), + mNonTailRequests(0), + mAfterDOMContentLoaded(false) { + LOG(("RequestContext::RequestContext this=%p id=%" PRIx64, this, mID)); +} + +RequestContext::~RequestContext() { + MOZ_ASSERT(mTailQueue.Length() == 0); + + LOG(("RequestContext::~RequestContext this=%p blockers=%u", this, + static_cast<uint32_t>(mBlockingTransactionCount))); +} + +NS_IMETHODIMP +RequestContext::BeginLoad() { + MOZ_ASSERT(NS_IsMainThread()); + + LOG(("RequestContext::BeginLoad %p", this)); + + if (IsNeckoChild()) { + // Tailing is not supported on the child process + if (gNeckoChild) { + gNeckoChild->SendRequestContextLoadBegin(mID); + } + return NS_OK; + } + + mAfterDOMContentLoaded = false; + mBeginLoadTime = TimeStamp::NowLoRes(); + return NS_OK; +} + +NS_IMETHODIMP +RequestContext::DOMContentLoaded() { + MOZ_ASSERT(NS_IsMainThread()); + + LOG(("RequestContext::DOMContentLoaded %p", this)); + + if (IsNeckoChild()) { + // Tailing is not supported on the child process + if (gNeckoChild) { + gNeckoChild->SendRequestContextAfterDOMContentLoaded(mID); + } + return NS_OK; + } + + if (mAfterDOMContentLoaded) { + // There is a possibility of a duplicate notification + return NS_OK; + } + + mAfterDOMContentLoaded = true; + + // Conditions for the delay calculation has changed. + ScheduleUnblock(); + return NS_OK; +} + +NS_IMETHODIMP +RequestContext::GetBlockingTransactionCount( + uint32_t* aBlockingTransactionCount) { + NS_ENSURE_ARG_POINTER(aBlockingTransactionCount); + *aBlockingTransactionCount = mBlockingTransactionCount; + return NS_OK; +} + +NS_IMETHODIMP +RequestContext::AddBlockingTransaction() { + mBlockingTransactionCount++; + LOG(("RequestContext::AddBlockingTransaction this=%p blockers=%u", this, + static_cast<uint32_t>(mBlockingTransactionCount))); + return NS_OK; +} + +NS_IMETHODIMP +RequestContext::RemoveBlockingTransaction(uint32_t* outval) { + NS_ENSURE_ARG_POINTER(outval); + mBlockingTransactionCount--; + LOG(("RequestContext::RemoveBlockingTransaction this=%p blockers=%u", this, + static_cast<uint32_t>(mBlockingTransactionCount))); + *outval = mBlockingTransactionCount; + return NS_OK; +} + +SpdyPushCache* RequestContext::GetSpdyPushCache() { return mSpdyCache.get(); } + +void RequestContext::SetSpdyPushCache(SpdyPushCache* aSpdyPushCache) { + mSpdyCache = WrapUnique(aSpdyPushCache); +} + +uint64_t RequestContext::GetID() { return mID; } + +NS_IMETHODIMP +RequestContext::AddNonTailRequest() { + MOZ_ASSERT(NS_IsMainThread()); + + ++mNonTailRequests; + LOG(("RequestContext::AddNonTailRequest this=%p, cnt=%u", this, + mNonTailRequests)); + + ScheduleUnblock(); + return NS_OK; +} + +NS_IMETHODIMP +RequestContext::RemoveNonTailRequest() { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(mNonTailRequests > 0); + + LOG(("RequestContext::RemoveNonTailRequest this=%p, cnt=%u", this, + mNonTailRequests - 1)); + + --mNonTailRequests; + + ScheduleUnblock(); + return NS_OK; +} + +void RequestContext::ScheduleUnblock() { + MOZ_ASSERT(!IsNeckoChild()); + MOZ_ASSERT(NS_IsMainThread()); + + if (!gHttpHandler) { + return; + } + + uint32_t quantum = + gHttpHandler->TailBlockingDelayQuantum(mAfterDOMContentLoaded); + uint32_t delayMax = gHttpHandler->TailBlockingDelayMax(); + uint32_t totalMax = gHttpHandler->TailBlockingTotalMax(); + + if (!mBeginLoadTime.IsNull()) { + // We decrease the maximum delay progressively with the time since the page + // load begin. This seems like a reasonable and clear heuristic allowing us + // to start loading tailed requests in a deterministic time after the load + // has started. + + uint32_t sinceBeginLoad = static_cast<uint32_t>( + (TimeStamp::NowLoRes() - mBeginLoadTime).ToMilliseconds()); + uint32_t tillTotal = totalMax - std::min(sinceBeginLoad, totalMax); + uint32_t proportion = totalMax // values clamped between 0 and 60'000 + ? (delayMax * tillTotal) / totalMax + : 0; + delayMax = std::min(delayMax, proportion); + } + + CheckedInt<uint32_t> delay = quantum * mNonTailRequests; + + if (!mAfterDOMContentLoaded) { + // Before DOMContentLoaded notification we want to make sure that tailed + // requests don't start when there is a short delay during which we may + // not have any active requests on the page happening. + delay += quantum; + } + + if (!delay.isValid() || delay.value() > delayMax) { + delay = delayMax; + } + + LOG( + ("RequestContext::ScheduleUnblock this=%p non-tails=%u tail-queue=%zu " + "delay=%u after-DCL=%d", + this, mNonTailRequests, mTailQueue.Length(), delay.value(), + mAfterDOMContentLoaded)); + + TimeStamp now = TimeStamp::NowLoRes(); + mUntailAt = now + TimeDuration::FromMilliseconds(delay.value()); + + if (mTimerScheduledAt.IsNull() || mUntailAt < mTimerScheduledAt) { + LOG(("RequestContext %p timer would fire too late, rescheduling", this)); + RescheduleUntailTimer(now); + } +} + +void RequestContext::RescheduleUntailTimer(TimeStamp const& now) { + MOZ_ASSERT(mUntailAt >= now); + + if (mUntailTimer) { + mUntailTimer->Cancel(); + } + + if (!mTailQueue.Length()) { + mUntailTimer = nullptr; + mTimerScheduledAt = TimeStamp(); + return; + } + + TimeDuration interval = mUntailAt - now; + if (!mTimerScheduledAt.IsNull() && mUntailAt < mTimerScheduledAt) { + // When the number of untailed requests goes down, + // let's half the interval, since it's likely we would + // reschedule for a shorter time again very soon. + // This will likely save rescheduling this timer. + interval = interval / int64_t(2); + mTimerScheduledAt = mUntailAt - interval; + } else { + mTimerScheduledAt = mUntailAt; + } + + uint32_t delay = interval.ToMilliseconds(); + mUntailTimer = do_CreateInstance("@mozilla.org/timer;1"); + mUntailTimer->InitWithCallback(this, delay, nsITimer::TYPE_ONE_SHOT); + + LOG(("RequestContext::RescheduleUntailTimer %p in %d", this, delay)); +} + +NS_IMETHODIMP +RequestContext::Notify(nsITimer* timer) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(timer == mUntailTimer); + MOZ_ASSERT(!mTimerScheduledAt.IsNull()); + MOZ_ASSERT(mTailQueue.Length()); + + mUntailTimer = nullptr; + + TimeStamp now = TimeStamp::NowLoRes(); + if (mUntailAt > mTimerScheduledAt && mUntailAt > now) { + LOG(("RequestContext %p timer fired too soon, rescheduling", this)); + RescheduleUntailTimer(now); + return NS_OK; + } + + // Must drop to allow re-engage of the timer + mTimerScheduledAt = TimeStamp(); + + ProcessTailQueue(NS_OK); + + return NS_OK; +} + +NS_IMETHODIMP +RequestContext::IsContextTailBlocked(nsIRequestTailUnblockCallback* aRequest, + bool* aBlocked) { + MOZ_ASSERT(NS_IsMainThread()); + + LOG(("RequestContext::IsContextTailBlocked this=%p, request=%p, queued=%zu", + this, aRequest, mTailQueue.Length())); + + *aBlocked = false; + + if (sShutdown) { + return NS_ERROR_ILLEGAL_DURING_SHUTDOWN; + } + + if (mUntailAt.IsNull()) { + LOG((" untail time passed")); + return NS_OK; + } + + if (mAfterDOMContentLoaded && !mNonTailRequests) { + LOG((" after DOMContentLoaded and no untailed requests")); + return NS_OK; + } + + if (!gHttpHandler) { + // Xpcshell tests may not have http handler + LOG((" missing gHttpHandler?")); + return NS_OK; + } + + *aBlocked = true; + mTailQueue.AppendElement(aRequest); + + LOG((" request queued")); + + if (!mUntailTimer) { + ScheduleUnblock(); + } + + return NS_OK; +} + +NS_IMETHODIMP +RequestContext::CancelTailedRequest(nsIRequestTailUnblockCallback* aRequest) { + MOZ_ASSERT(NS_IsMainThread()); + + bool removed = mTailQueue.RemoveElement(aRequest); + + LOG(("RequestContext::CancelTailedRequest %p req=%p removed=%d", this, + aRequest, removed)); + + // Stop untail timer if all tail requests are canceled. + if (removed && mTailQueue.IsEmpty()) { + if (mUntailTimer) { + mUntailTimer->Cancel(); + mUntailTimer = nullptr; + } + + // Must drop to allow re-engage of the timer + mTimerScheduledAt = TimeStamp(); + } + + return NS_OK; +} + +void RequestContext::ProcessTailQueue(nsresult aResult) { + LOG(("RequestContext::ProcessTailQueue this=%p, queued=%zu, rv=%" PRIx32, + this, mTailQueue.Length(), static_cast<uint32_t>(aResult))); + + if (mUntailTimer) { + mUntailTimer->Cancel(); + mUntailTimer = nullptr; + } + + // Must drop to stop tailing requests + mUntailAt = TimeStamp(); + + nsTArray<PendingTailRequest> queue = std::move(mTailQueue); + + for (const auto& request : queue) { + LOG((" untailing %p", request.get())); + request->OnTailUnblock(aResult); + } +} + +NS_IMETHODIMP +RequestContext::CancelTailPendingRequests(nsresult aResult) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(NS_FAILED(aResult)); + + ProcessTailQueue(aResult); + return NS_OK; +} + +// nsIRequestContextService +RequestContextService* RequestContextService::sSelf = nullptr; + +NS_IMPL_ISUPPORTS(RequestContextService, nsIRequestContextService, nsIObserver) + +RequestContextService::RequestContextService() + : mRCIDNamespace(0), mNextRCID(1) { + MOZ_ASSERT(!sSelf, "multiple rcs instances!"); + MOZ_ASSERT(NS_IsMainThread()); + sSelf = this; + + nsCOMPtr<nsIXULRuntime> runtime = do_GetService("@mozilla.org/xre/runtime;1"); + runtime->GetProcessID(&mRCIDNamespace); +} + +RequestContextService::~RequestContextService() { + MOZ_ASSERT(NS_IsMainThread()); + Shutdown(); + sSelf = nullptr; +} + +nsresult RequestContextService::Init() { + nsresult rv; + + MOZ_ASSERT(NS_IsMainThread()); + nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); + if (!obs) { + return NS_ERROR_NOT_AVAILABLE; + } + + rv = obs->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false); + if (NS_FAILED(rv)) { + return rv; + } + obs->AddObserver(this, "content-document-interactive", false); + if (NS_FAILED(rv)) { + return rv; + } + + return NS_OK; +} + +void RequestContextService::Shutdown() { + MOZ_ASSERT(NS_IsMainThread()); + // We need to do this to prevent the requests from being scheduled after + // shutdown. + for (auto iter = mTable.Iter(); !iter.Done(); iter.Next()) { + iter.Data()->CancelTailPendingRequests(NS_ERROR_ABORT); + } + mTable.Clear(); + sShutdown = true; +} + +/* static */ +already_AddRefed<nsIRequestContextService> +RequestContextService::GetOrCreate() { + MOZ_ASSERT(NS_IsMainThread()); + + if (sShutdown) { + return nullptr; + } + + RefPtr<RequestContextService> svc; + if (gSingleton) { + svc = gSingleton; + } else { + svc = new RequestContextService(); + nsresult rv = svc->Init(); + NS_ENSURE_SUCCESS(rv, nullptr); + gSingleton = svc; + ClearOnShutdown(&gSingleton); + } + + return svc.forget(); +} + +NS_IMETHODIMP +RequestContextService::GetRequestContext(const uint64_t rcID, + nsIRequestContext** rc) { + MOZ_ASSERT(NS_IsMainThread()); + NS_ENSURE_ARG_POINTER(rc); + *rc = nullptr; + + if (sShutdown) { + return NS_ERROR_ILLEGAL_DURING_SHUTDOWN; + } + + if (!rcID) { + return NS_ERROR_INVALID_ARG; + } + + if (!mTable.Get(rcID, rc)) { + nsCOMPtr<nsIRequestContext> newSC = new RequestContext(rcID); + mTable.Put(rcID, newSC); + newSC.swap(*rc); + } + + return NS_OK; +} + +NS_IMETHODIMP +RequestContextService::GetRequestContextFromLoadGroup(nsILoadGroup* aLoadGroup, + nsIRequestContext** rc) { + nsresult rv; + + uint64_t rcID; + rv = aLoadGroup->GetRequestContextID(&rcID); + if (NS_FAILED(rv)) { + return rv; + } + + return GetRequestContext(rcID, rc); +} + +NS_IMETHODIMP +RequestContextService::NewRequestContext(nsIRequestContext** rc) { + MOZ_ASSERT(NS_IsMainThread()); + NS_ENSURE_ARG_POINTER(rc); + *rc = nullptr; + + if (sShutdown) { + return NS_ERROR_ILLEGAL_DURING_SHUTDOWN; + } + + uint64_t rcID = + ((static_cast<uint64_t>(mRCIDNamespace) << 32) & 0xFFFFFFFF00000000LL) | + mNextRCID++; + + nsCOMPtr<nsIRequestContext> newSC = new RequestContext(rcID); + mTable.Put(rcID, newSC); + newSC.swap(*rc); + + return NS_OK; +} + +NS_IMETHODIMP +RequestContextService::RemoveRequestContext(const uint64_t rcID) { + MOZ_ASSERT(NS_IsMainThread()); + mTable.Remove(rcID); + return NS_OK; +} + +NS_IMETHODIMP +RequestContextService::Observe(nsISupports* subject, const char* topic, + const char16_t* data_unicode) { + MOZ_ASSERT(NS_IsMainThread()); + if (!strcmp(NS_XPCOM_SHUTDOWN_OBSERVER_ID, topic)) { + Shutdown(); + return NS_OK; + } + + if (!strcmp("content-document-interactive", topic)) { + nsCOMPtr<dom::Document> document(do_QueryInterface(subject)); + MOZ_ASSERT(document); + // We want this be triggered also for iframes, since those track their + // own request context ids. + if (!document) { + return NS_OK; + } + nsIDocShell* ds = document->GetDocShell(); + // XML documents don't always have a docshell assigned + if (!ds) { + return NS_OK; + } + nsCOMPtr<nsIDocumentLoader> dl(do_QueryInterface(ds)); + if (!dl) { + return NS_OK; + } + nsCOMPtr<nsILoadGroup> lg; + dl->GetLoadGroup(getter_AddRefs(lg)); + if (!lg) { + return NS_OK; + } + nsCOMPtr<nsIRequestContext> rc; + GetRequestContextFromLoadGroup(lg, getter_AddRefs(rc)); + if (rc) { + rc->DOMContentLoaded(); + } + + return NS_OK; + } + + MOZ_ASSERT(false, "Unexpected observer topic"); + return NS_OK; +} + +} // namespace net +} // namespace mozilla + +#undef LOG diff --git a/netwerk/base/RequestContextService.h b/netwerk/base/RequestContextService.h new file mode 100644 index 0000000000..e862969ff1 --- /dev/null +++ b/netwerk/base/RequestContextService.h @@ -0,0 +1,44 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 ;*; */ +/* vim: set sw=2 ts=8 et tw=80 : */ +/* 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/. */ + +#ifndef mozilla__net__RequestContextService_h +#define mozilla__net__RequestContextService_h + +#include "nsCOMPtr.h" +#include "nsInterfaceHashtable.h" +#include "nsIObserver.h" +#include "nsIRequestContext.h" + +namespace mozilla { +namespace net { + +class RequestContextService final : public nsIRequestContextService, + public nsIObserver { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIREQUESTCONTEXTSERVICE + NS_DECL_NSIOBSERVER + + static already_AddRefed<nsIRequestContextService> GetOrCreate(); + + private: + RequestContextService(); + virtual ~RequestContextService(); + + nsresult Init(); + void Shutdown(); + + static RequestContextService* sSelf; + + nsInterfaceHashtable<nsUint64HashKey, nsIRequestContext> mTable; + uint32_t mRCIDNamespace; + uint32_t mNextRCID; +}; + +} // namespace net +} // namespace mozilla + +#endif // mozilla__net__RequestContextService_h diff --git a/netwerk/base/SSLTokensCache.cpp b/netwerk/base/SSLTokensCache.cpp new file mode 100644 index 0000000000..46d3a3bace --- /dev/null +++ b/netwerk/base/SSLTokensCache.cpp @@ -0,0 +1,414 @@ +/* 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 "SSLTokensCache.h" +#include "mozilla/ArrayAlgorithm.h" +#include "mozilla/Preferences.h" +#include "mozilla/Logging.h" +#include "nsIOService.h" +#include "nsNSSIOLayer.h" +#include "TransportSecurityInfo.h" +#include "ssl.h" +#include "sslexp.h" + +namespace mozilla { +namespace net { + +static LazyLogModule gSSLTokensCacheLog("SSLTokensCache"); +#undef LOG +#define LOG(args) MOZ_LOG(gSSLTokensCacheLog, mozilla::LogLevel::Debug, args) + +class ExpirationComparator { + public: + bool Equals(SSLTokensCache::TokenCacheRecord* a, + SSLTokensCache::TokenCacheRecord* b) const { + return a->mExpirationTime == b->mExpirationTime; + } + bool LessThan(SSLTokensCache::TokenCacheRecord* a, + SSLTokensCache::TokenCacheRecord* b) const { + return a->mExpirationTime < b->mExpirationTime; + } +}; + +SessionCacheInfo SessionCacheInfo::Clone() const { + SessionCacheInfo result; + result.mEVStatus = mEVStatus; + result.mCertificateTransparencyStatus = mCertificateTransparencyStatus; + result.mServerCertBytes = mServerCertBytes.Clone(); + result.mSucceededCertChainBytes = + mSucceededCertChainBytes + ? Some(TransformIntoNewArray( + *mSucceededCertChainBytes, + [](const auto& element) { return element.Clone(); })) + : Nothing(); + return result; +} + +StaticRefPtr<SSLTokensCache> SSLTokensCache::gInstance; +StaticMutex SSLTokensCache::sLock; + +uint32_t SSLTokensCache::TokenCacheRecord::Size() const { + uint32_t size = mToken.Length() + sizeof(mSessionCacheInfo.mEVStatus) + + sizeof(mSessionCacheInfo.mCertificateTransparencyStatus) + + mSessionCacheInfo.mServerCertBytes.Length(); + if (mSessionCacheInfo.mSucceededCertChainBytes) { + for (const auto& cert : mSessionCacheInfo.mSucceededCertChainBytes.ref()) { + size += cert.Length(); + } + } + return size; +} + +void SSLTokensCache::TokenCacheRecord::Reset() { + mToken.Clear(); + mExpirationTime = 0; + mSessionCacheInfo.mEVStatus = psm::EVStatus::NotEV; + mSessionCacheInfo.mCertificateTransparencyStatus = + nsITransportSecurityInfo::CERTIFICATE_TRANSPARENCY_NOT_APPLICABLE; + mSessionCacheInfo.mServerCertBytes.Clear(); + mSessionCacheInfo.mSucceededCertChainBytes.reset(); +} + +NS_IMPL_ISUPPORTS(SSLTokensCache, nsIMemoryReporter) + +// static +nsresult SSLTokensCache::Init() { + StaticMutexAutoLock lock(sLock); + + // SSLTokensCache should be only used in parent process and socket process. + // Ideally, parent process should not use this when socket process is enabled. + // However, some xpcsehll tests may need to create and use sockets directly, + // so we still allow to use this in parent process no matter socket process is + // enabled or not. + if (!(XRE_IsSocketProcess() || XRE_IsParentProcess())) { + return NS_OK; + } + + MOZ_ASSERT(!gInstance); + + gInstance = new SSLTokensCache(); + + RegisterWeakMemoryReporter(gInstance); + + return NS_OK; +} + +// static +nsresult SSLTokensCache::Shutdown() { + StaticMutexAutoLock lock(sLock); + + if (!gInstance) { + return NS_ERROR_UNEXPECTED; + } + + UnregisterWeakMemoryReporter(gInstance); + + gInstance = nullptr; + + return NS_OK; +} + +SSLTokensCache::SSLTokensCache() : mCacheSize(0) { + LOG(("SSLTokensCache::SSLTokensCache")); +} + +SSLTokensCache::~SSLTokensCache() { LOG(("SSLTokensCache::~SSLTokensCache")); } + +// static +nsresult SSLTokensCache::Put(const nsACString& aKey, const uint8_t* aToken, + uint32_t aTokenLen, + nsITransportSecurityInfo* aSecInfo) { + PRUint32 expirationTime; + SSLResumptionTokenInfo tokenInfo; + if (SSL_GetResumptionTokenInfo(aToken, aTokenLen, &tokenInfo, + sizeof(tokenInfo)) != SECSuccess) { + LOG((" cannot get expiration time from the token, NSS error %d", + PORT_GetError())); + return NS_ERROR_FAILURE; + } + + expirationTime = tokenInfo.expirationTime; + SSL_DestroyResumptionTokenInfo(&tokenInfo); + + return Put(aKey, aToken, aTokenLen, aSecInfo, expirationTime); +} + +// static +nsresult SSLTokensCache::Put(const nsACString& aKey, const uint8_t* aToken, + uint32_t aTokenLen, + nsITransportSecurityInfo* aSecInfo, + PRUint32 aExpirationTime) { + StaticMutexAutoLock lock(sLock); + + LOG(("SSLTokensCache::Put [key=%s, tokenLen=%u]", + PromiseFlatCString(aKey).get(), aTokenLen)); + + if (!gInstance) { + LOG((" service not initialized")); + return NS_ERROR_NOT_INITIALIZED; + } + + if (!aSecInfo) { + return NS_ERROR_FAILURE; + } + + nsCOMPtr<nsIX509Cert> cert; + aSecInfo->GetServerCert(getter_AddRefs(cert)); + if (!cert) { + return NS_ERROR_FAILURE; + } + + nsTArray<uint8_t> certBytes; + nsresult rv = cert->GetRawDER(certBytes); + if (NS_FAILED(rv)) { + return rv; + } + + Maybe<nsTArray<nsTArray<uint8_t>>> succeededCertChainBytes; + nsTArray<RefPtr<nsIX509Cert>> succeededCertArray; + rv = aSecInfo->GetSucceededCertChain(succeededCertArray); + if (NS_FAILED(rv)) { + return rv; + } + + Maybe<bool> isBuiltCertChainRootBuiltInRoot; + if (!succeededCertArray.IsEmpty()) { + succeededCertChainBytes.emplace(); + for (const auto& cert : succeededCertArray) { + nsTArray<uint8_t> rawCert; + nsresult rv = cert->GetRawDER(rawCert); + if (NS_FAILED(rv)) { + return rv; + } + succeededCertChainBytes->AppendElement(std::move(rawCert)); + } + + bool builtInRoot = false; + rv = aSecInfo->GetIsBuiltCertChainRootBuiltInRoot(&builtInRoot); + if (NS_FAILED(rv)) { + return rv; + } + isBuiltCertChainRootBuiltInRoot.emplace(builtInRoot); + } + + bool isEV; + rv = aSecInfo->GetIsExtendedValidation(&isEV); + if (NS_FAILED(rv)) { + return rv; + } + + uint16_t certificateTransparencyStatus; + rv = aSecInfo->GetCertificateTransparencyStatus( + &certificateTransparencyStatus); + if (NS_FAILED(rv)) { + return rv; + } + + TokenCacheRecord* rec = nullptr; + + if (!gInstance->mTokenCacheRecords.Get(aKey, &rec)) { + rec = new TokenCacheRecord(); + rec->mKey = aKey; + gInstance->mTokenCacheRecords.Put(aKey, rec); + gInstance->mExpirationArray.AppendElement(rec); + } else { + gInstance->mCacheSize -= rec->Size(); + rec->Reset(); + } + + rec->mExpirationTime = aExpirationTime; + MOZ_ASSERT(rec->mToken.IsEmpty()); + rec->mToken.AppendElements(aToken, aTokenLen); + + rec->mSessionCacheInfo.mServerCertBytes = std::move(certBytes); + + rec->mSessionCacheInfo.mSucceededCertChainBytes = + succeededCertChainBytes + ? Some(TransformIntoNewArray( + *succeededCertChainBytes, + [](auto& element) { return nsTArray(std::move(element)); })) + : Nothing(); + + if (isEV) { + rec->mSessionCacheInfo.mEVStatus = psm::EVStatus::EV; + } + + rec->mSessionCacheInfo.mCertificateTransparencyStatus = + certificateTransparencyStatus; + + rec->mSessionCacheInfo.mIsBuiltCertChainRootBuiltInRoot = + std::move(isBuiltCertChainRootBuiltInRoot); + + gInstance->mCacheSize += rec->Size(); + + gInstance->LogStats(); + + gInstance->EvictIfNecessary(); + + return NS_OK; +} + +// static +nsresult SSLTokensCache::Get(const nsACString& aKey, + nsTArray<uint8_t>& aToken) { + StaticMutexAutoLock lock(sLock); + + LOG(("SSLTokensCache::Get [key=%s]", PromiseFlatCString(aKey).get())); + + if (!gInstance) { + LOG((" service not initialized")); + return NS_ERROR_NOT_INITIALIZED; + } + + TokenCacheRecord* rec = nullptr; + + if (gInstance->mTokenCacheRecords.Get(aKey, &rec)) { + if (rec->mToken.Length()) { + aToken = rec->mToken.Clone(); + return NS_OK; + } + } + + LOG((" token not found")); + return NS_ERROR_NOT_AVAILABLE; +} + +// static +bool SSLTokensCache::GetSessionCacheInfo(const nsACString& aKey, + SessionCacheInfo& aResult) { + StaticMutexAutoLock lock(sLock); + + LOG(("SSLTokensCache::GetSessionCacheInfo [key=%s]", + PromiseFlatCString(aKey).get())); + + if (!gInstance) { + LOG((" service not initialized")); + return false; + } + + TokenCacheRecord* rec = nullptr; + + if (gInstance->mTokenCacheRecords.Get(aKey, &rec)) { + aResult = rec->mSessionCacheInfo.Clone(); + return true; + } + + LOG((" token not found")); + return false; +} + +// static +nsresult SSLTokensCache::Remove(const nsACString& aKey) { + StaticMutexAutoLock lock(sLock); + + LOG(("SSLTokensCache::Remove [key=%s]", PromiseFlatCString(aKey).get())); + + if (!gInstance) { + LOG((" service not initialized")); + return NS_ERROR_NOT_INITIALIZED; + } + + return gInstance->RemoveLocked(aKey); +} + +nsresult SSLTokensCache::RemoveLocked(const nsACString& aKey) { + sLock.AssertCurrentThreadOwns(); + + LOG(("SSLTokensCache::RemoveLocked [key=%s]", + PromiseFlatCString(aKey).get())); + + UniquePtr<TokenCacheRecord> rec; + + if (!mTokenCacheRecords.Remove(aKey, &rec)) { + LOG((" token not found")); + return NS_ERROR_NOT_AVAILABLE; + } + + mCacheSize -= rec->Size(); + + if (!mExpirationArray.RemoveElement(rec.get())) { + MOZ_ASSERT(false, "token not found in mExpirationArray"); + } + + LogStats(); + + return NS_OK; +} + +void SSLTokensCache::EvictIfNecessary() { + // kilobytes to bytes + uint32_t capacity = StaticPrefs::network_ssl_tokens_cache_capacity() << 10; + if (mCacheSize <= capacity) { + return; + } + + LOG(("SSLTokensCache::EvictIfNecessary - evicting")); + + mExpirationArray.Sort(ExpirationComparator()); + + while (mCacheSize > capacity && mExpirationArray.Length() > 0) { + if (NS_FAILED(RemoveLocked(mExpirationArray[0]->mKey))) { + MOZ_ASSERT(false, + "mExpirationArray and mTokenCacheRecords are out of sync!"); + mExpirationArray.RemoveElementAt(0); + } + } +} + +void SSLTokensCache::LogStats() { + LOG(("SSLTokensCache::LogStats [count=%zu, cacheSize=%u]", + mExpirationArray.Length(), mCacheSize)); +} + +size_t SSLTokensCache::SizeOfIncludingThis( + mozilla::MallocSizeOf mallocSizeOf) const { + size_t n = mallocSizeOf(this); + + n += mTokenCacheRecords.ShallowSizeOfExcludingThis(mallocSizeOf); + n += mExpirationArray.ShallowSizeOfExcludingThis(mallocSizeOf); + + for (uint32_t i = 0; i < mExpirationArray.Length(); ++i) { + n += mallocSizeOf(mExpirationArray[i]); + n += mExpirationArray[i]->mKey.SizeOfExcludingThisIfUnshared(mallocSizeOf); + n += mExpirationArray[i]->mToken.ShallowSizeOfExcludingThis(mallocSizeOf); + } + + return n; +} + +MOZ_DEFINE_MALLOC_SIZE_OF(SSLTokensCacheMallocSizeOf) + +NS_IMETHODIMP +SSLTokensCache::CollectReports(nsIHandleReportCallback* aHandleReport, + nsISupports* aData, bool aAnonymize) { + StaticMutexAutoLock lock(sLock); + + MOZ_COLLECT_REPORT("explicit/network/ssl-tokens-cache", KIND_HEAP, + UNITS_BYTES, + SizeOfIncludingThis(SSLTokensCacheMallocSizeOf), + "Memory used for the SSL tokens cache."); + + return NS_OK; +} + +// static +void SSLTokensCache::Clear() { + LOG(("SSLTokensCache::Clear")); + if (!StaticPrefs::network_ssl_tokens_cache_enabled()) { + return; + } + + StaticMutexAutoLock lock(sLock); + if (!gInstance) { + LOG((" service not initialized")); + return; + } + + gInstance->mExpirationArray.Clear(); + gInstance->mTokenCacheRecords.Clear(); + gInstance->mCacheSize = 0; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/SSLTokensCache.h b/netwerk/base/SSLTokensCache.h new file mode 100644 index 0000000000..9ccff1b424 --- /dev/null +++ b/netwerk/base/SSLTokensCache.h @@ -0,0 +1,87 @@ +/* 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/. */ + +#ifndef SSLTokensCache_h_ +#define SSLTokensCache_h_ + +#include "nsIMemoryReporter.h" +#include "nsClassHashtable.h" +#include "nsTArray.h" +#include "mozilla/Maybe.h" +#include "mozilla/StaticMutex.h" +#include "mozilla/StaticPrefs_network.h" +#include "mozilla/StaticPtr.h" +#include "nsXULAppAPI.h" +#include "TransportSecurityInfo.h" // For EVStatus + +namespace mozilla { +namespace net { + +struct SessionCacheInfo { + SessionCacheInfo Clone() const; + + psm::EVStatus mEVStatus = psm::EVStatus::NotEV; + uint16_t mCertificateTransparencyStatus = + nsITransportSecurityInfo::CERTIFICATE_TRANSPARENCY_NOT_APPLICABLE; + nsTArray<uint8_t> mServerCertBytes; + Maybe<nsTArray<nsTArray<uint8_t>>> mSucceededCertChainBytes; + Maybe<bool> mIsBuiltCertChainRootBuiltInRoot; +}; + +class SSLTokensCache : public nsIMemoryReporter { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIMEMORYREPORTER + + friend class ExpirationComparator; + + static nsresult Init(); + static nsresult Shutdown(); + + static nsresult Put(const nsACString& aKey, const uint8_t* aToken, + uint32_t aTokenLen, nsITransportSecurityInfo* aSecInfo); + static nsresult Put(const nsACString& aKey, const uint8_t* aToken, + uint32_t aTokenLen, nsITransportSecurityInfo* aSecInfo, + PRUint32 aExpirationTime); + static nsresult Get(const nsACString& aKey, nsTArray<uint8_t>& aToken); + static bool GetSessionCacheInfo(const nsACString& aKey, + SessionCacheInfo& aResult); + static nsresult Remove(const nsACString& aKey); + static void Clear(); + + private: + SSLTokensCache(); + virtual ~SSLTokensCache(); + + nsresult RemoveLocked(const nsACString& aKey); + + void EvictIfNecessary(); + void LogStats(); + + size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const; + + static mozilla::StaticRefPtr<SSLTokensCache> gInstance; + static StaticMutex sLock; + + uint32_t mCacheSize; // Actual cache size in bytes + + class TokenCacheRecord { + public: + uint32_t Size() const; + void Reset(); + + nsCString mKey; + PRUint32 mExpirationTime; + nsTArray<uint8_t> mToken; + SessionCacheInfo mSessionCacheInfo; + }; + + nsClassHashtable<nsCStringHashKey, TokenCacheRecord> mTokenCacheRecords; + nsTArray<TokenCacheRecord*> mExpirationArray; +}; + +} // namespace net +} // namespace mozilla + +#endif // SSLTokensCache_h_ diff --git a/netwerk/base/ShutdownLayer.cpp b/netwerk/base/ShutdownLayer.cpp new file mode 100644 index 0000000000..db62ea691d --- /dev/null +++ b/netwerk/base/ShutdownLayer.cpp @@ -0,0 +1,76 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * 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 "mozilla/Assertions.h" +#include "ShutdownLayer.h" +#include "prerror.h" +#include "private/pprio.h" +#include "prmem.h" +#include <winsock2.h> + +static PRDescIdentity sWinSockShutdownLayerIdentity; +static PRIOMethods sWinSockShutdownLayerMethods; +static PRIOMethods* sWinSockShutdownLayerMethodsPtr = nullptr; + +namespace mozilla { +namespace net { + +extern PRDescIdentity nsNamedPipeLayerIdentity; + +} // namespace net +} // namespace mozilla + +PRStatus WinSockClose(PRFileDesc* aFd) { + MOZ_RELEASE_ASSERT(aFd->identity == sWinSockShutdownLayerIdentity, + "Windows shutdown layer not on the top of the stack"); + + PROsfd osfd = PR_FileDesc2NativeHandle(aFd); + if (osfd != -1) { + shutdown(osfd, SD_BOTH); + } + + aFd->identity = PR_INVALID_IO_LAYER; + + if (aFd->lower) { + return aFd->lower->methods->close(aFd->lower); + } else { + return PR_SUCCESS; + } +} + +nsresult mozilla::net::AttachShutdownLayer(PRFileDesc* aFd) { + if (!sWinSockShutdownLayerMethodsPtr) { + sWinSockShutdownLayerIdentity = + PR_GetUniqueIdentity("windows shutdown call layer"); + sWinSockShutdownLayerMethods = *PR_GetDefaultIOMethods(); + sWinSockShutdownLayerMethods.close = WinSockClose; + sWinSockShutdownLayerMethodsPtr = &sWinSockShutdownLayerMethods; + } + + if (mozilla::net::nsNamedPipeLayerIdentity && + PR_GetIdentitiesLayer(aFd, mozilla::net::nsNamedPipeLayerIdentity)) { + // Do not attach shutdown layer on named pipe layer, + // it is for PR_NSPR_IO_LAYER only. + return NS_OK; + } + + PRFileDesc* layer; + PRStatus status; + + layer = PR_CreateIOLayerStub(sWinSockShutdownLayerIdentity, + sWinSockShutdownLayerMethodsPtr); + if (!layer) { + return NS_OK; + } + + status = PR_PushIOLayer(aFd, PR_NSPR_IO_LAYER, layer); + + if (status == PR_FAILURE) { + PR_Free(layer); // PR_CreateIOLayerStub() uses PR_Malloc(). + return NS_ERROR_FAILURE; + } + return NS_OK; +} diff --git a/netwerk/base/ShutdownLayer.h b/netwerk/base/ShutdownLayer.h new file mode 100644 index 0000000000..2bf68fdcdc --- /dev/null +++ b/netwerk/base/ShutdownLayer.h @@ -0,0 +1,23 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * 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/. */ + +#ifndef SHUTDOWNLAYER_H___ +#define SHUTDOWNLAYER_H___ + +#include "nscore.h" +#include "prio.h" + +namespace mozilla { +namespace net { + +// This is only for windows. This layer will be attached jus before PR_CLose +// is call and it will only call shutdown(sock). +extern nsresult AttachShutdownLayer(PRFileDesc* fd); + +} // namespace net +} // namespace mozilla + +#endif /* SHUTDOWN_H___ */ diff --git a/netwerk/base/SimpleBuffer.cpp b/netwerk/base/SimpleBuffer.cpp new file mode 100644 index 0000000000..1791a34b59 --- /dev/null +++ b/netwerk/base/SimpleBuffer.cpp @@ -0,0 +1,87 @@ +/* -*- 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 "SimpleBuffer.h" +#include <algorithm> + +namespace mozilla { +namespace net { + +SimpleBuffer::SimpleBuffer() : mStatus(NS_OK), mAvailable(0) {} + +nsresult SimpleBuffer::Write(char* src, size_t len) { + NS_ASSERT_OWNINGTHREAD(SimpleBuffer); + if (NS_FAILED(mStatus)) { + return mStatus; + } + + while (len > 0) { + SimpleBufferPage* p = mBufferList.getLast(); + if (p && (p->mWriteOffset == SimpleBufferPage::kSimpleBufferPageSize)) { + // no room.. make a new page + p = nullptr; + } + if (!p) { + p = new (fallible) SimpleBufferPage(); + if (!p) { + mStatus = NS_ERROR_OUT_OF_MEMORY; + return mStatus; + } + mBufferList.insertBack(p); + } + size_t roomOnPage = + SimpleBufferPage::kSimpleBufferPageSize - p->mWriteOffset; + size_t toWrite = std::min(roomOnPage, len); + memcpy(p->mBuffer + p->mWriteOffset, src, toWrite); + src += toWrite; + len -= toWrite; + p->mWriteOffset += toWrite; + mAvailable += toWrite; + } + return NS_OK; +} + +size_t SimpleBuffer::Read(char* dest, size_t maxLen) { + NS_ASSERT_OWNINGTHREAD(SimpleBuffer); + if (NS_FAILED(mStatus)) { + return 0; + } + + size_t rv = 0; + for (SimpleBufferPage* p = mBufferList.getFirst(); p && (rv < maxLen); + p = mBufferList.getFirst()) { + size_t avail = p->mWriteOffset - p->mReadOffset; + size_t toRead = std::min(avail, (maxLen - rv)); + memcpy(dest + rv, p->mBuffer + p->mReadOffset, toRead); + rv += toRead; + p->mReadOffset += toRead; + if (p->mReadOffset == p->mWriteOffset) { + p->remove(); + delete p; + } + } + + MOZ_ASSERT(mAvailable >= rv); + mAvailable -= rv; + return rv; +} + +size_t SimpleBuffer::Available() { + NS_ASSERT_OWNINGTHREAD(SimpleBuffer); + return NS_SUCCEEDED(mStatus) ? mAvailable : 0; +} + +void SimpleBuffer::Clear() { + NS_ASSERT_OWNINGTHREAD(SimpleBuffer); + SimpleBufferPage* p; + while ((p = mBufferList.popFirst())) { + delete p; + } + mAvailable = 0; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/SimpleBuffer.h b/netwerk/base/SimpleBuffer.h new file mode 100644 index 0000000000..c518d1b341 --- /dev/null +++ b/netwerk/base/SimpleBuffer.h @@ -0,0 +1,55 @@ +/* -*- 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/. */ + +#ifndef SimpleBuffer_h__ +#define SimpleBuffer_h__ + +/* + This class is similar to a nsPipe except it does not have any locking, stores + an unbounded amount of data, can only be used on one thread, and has much + simpler result code semantics to deal with. +*/ + +#include "prtypes.h" +#include "mozilla/LinkedList.h" + +namespace mozilla { +namespace net { + +class SimpleBufferPage : public LinkedListElement<SimpleBufferPage> { + public: + SimpleBufferPage() : mReadOffset(0), mWriteOffset(0) {} + static const size_t kSimpleBufferPageSize = 32000; + + private: + friend class SimpleBuffer; + char mBuffer[kSimpleBufferPageSize]; + size_t mReadOffset; + size_t mWriteOffset; +}; + +class SimpleBuffer { + public: + SimpleBuffer(); + ~SimpleBuffer() = default; + + nsresult Write(char* stc, size_t len); // return OK or OUT_OF_MEMORY + size_t Read(char* dest, size_t maxLen); // return bytes read + size_t Available(); + void Clear(); + + private: + NS_DECL_OWNINGTHREAD + + nsresult mStatus; + AutoCleanLinkedList<SimpleBufferPage> mBufferList; + size_t mAvailable; +}; + +} // namespace net +} // namespace mozilla + +#endif diff --git a/netwerk/base/SimpleChannel.cpp b/netwerk/base/SimpleChannel.cpp new file mode 100644 index 0000000000..c390418cb7 --- /dev/null +++ b/netwerk/base/SimpleChannel.cpp @@ -0,0 +1,118 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "SimpleChannel.h" + +#include "nsBaseChannel.h" +#include "nsIChannel.h" +#include "nsIChildChannel.h" +#include "nsIInputStream.h" +#include "nsIRequest.h" +#include "nsISupportsImpl.h" +#include "nsNetUtil.h" + +#include "mozilla/Unused.h" +#include "mozilla/dom/ContentChild.h" +#include "mozilla/net/NeckoChild.h" +#include "mozilla/net/PSimpleChannelChild.h" + +namespace mozilla { +namespace net { + +SimpleChannel::SimpleChannel(UniquePtr<SimpleChannelCallbacks>&& aCallbacks) + : mCallbacks(std::move(aCallbacks)) { + EnableSynthesizedProgressEvents(true); +} + +nsresult SimpleChannel::OpenContentStream(bool async, + nsIInputStream** streamOut, + nsIChannel** channel) { + NS_ENSURE_TRUE(mCallbacks, NS_ERROR_UNEXPECTED); + + nsCOMPtr<nsIInputStream> stream; + MOZ_TRY_VAR(stream, mCallbacks->OpenContentStream(async, this)); + MOZ_ASSERT(stream); + + mCallbacks = nullptr; + + *channel = nullptr; + stream.forget(streamOut); + return NS_OK; +} + +nsresult SimpleChannel::BeginAsyncRead(nsIStreamListener* listener, + nsIRequest** request) { + NS_ENSURE_TRUE(mCallbacks, NS_ERROR_UNEXPECTED); + + nsCOMPtr<nsIRequest> req; + MOZ_TRY_VAR(req, mCallbacks->StartAsyncRead(listener, this)); + + mCallbacks = nullptr; + + req.forget(request); + return NS_OK; +} + +NS_IMPL_ISUPPORTS_INHERITED(SimpleChannelChild, SimpleChannel, nsIChildChannel) + +SimpleChannelChild::SimpleChannelChild( + UniquePtr<SimpleChannelCallbacks>&& aCallbacks) + : SimpleChannel(std::move(aCallbacks)) {} + +NS_IMETHODIMP +SimpleChannelChild::ConnectParent(uint32_t aId) { + MOZ_ASSERT(NS_IsMainThread()); + mozilla::dom::ContentChild* cc = + static_cast<mozilla::dom::ContentChild*>(gNeckoChild->Manager()); + if (cc->IsShuttingDown()) { + return NS_ERROR_FAILURE; + } + + // Reference freed in DeallocPSimpleChannelChild. + if (!gNeckoChild->SendPSimpleChannelConstructor(do_AddRef(this).take(), + aId)) { + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +NS_IMETHODIMP +SimpleChannelChild::CompleteRedirectSetup(nsIStreamListener* aListener) { + if (CanSend()) { + MOZ_ASSERT(NS_IsMainThread()); + } + + nsresult rv; + rv = AsyncOpen(aListener); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + if (CanSend()) { + Unused << Send__delete__(this); + } + return NS_OK; +} + +already_AddRefed<nsIChannel> NS_NewSimpleChannelInternal( + nsIURI* aURI, nsILoadInfo* aLoadInfo, + UniquePtr<SimpleChannelCallbacks>&& aCallbacks) { + RefPtr<SimpleChannel> chan; + if (IsNeckoChild()) { + chan = new SimpleChannelChild(std::move(aCallbacks)); + } else { + chan = new SimpleChannel(std::move(aCallbacks)); + } + + chan->SetURI(aURI); + + MOZ_ALWAYS_SUCCEEDS(chan->SetLoadInfo(aLoadInfo)); + + return chan.forget(); +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/SimpleChannel.h b/netwerk/base/SimpleChannel.h new file mode 100644 index 0000000000..6e45c5bdb4 --- /dev/null +++ b/netwerk/base/SimpleChannel.h @@ -0,0 +1,147 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef SimpleChannel_h +#define SimpleChannel_h + +#include "mozilla/ResultExtensions.h" +#include "mozilla/UniquePtr.h" +#include "nsBaseChannel.h" +#include "nsIChildChannel.h" +#include "mozilla/net/PSimpleChannelChild.h" +#include "nsCOMPtr.h" + +class nsIChannel; +class nsIInputStream; +class nsILoadInfo; +class nsIRequest; +class nsIStreamListener; +class nsIURI; + +//----------------------------------------------------------------------------- + +namespace mozilla { + +using InputStreamOrReason = Result<nsCOMPtr<nsIInputStream>, nsresult>; +using RequestOrReason = Result<nsCOMPtr<nsIRequest>, nsresult>; + +namespace net { + +class SimpleChannelCallbacks { + public: + virtual InputStreamOrReason OpenContentStream(bool async, + nsIChannel* channel) = 0; + + virtual RequestOrReason StartAsyncRead(nsIStreamListener* stream, + nsIChannel* channel) = 0; + + virtual ~SimpleChannelCallbacks() = default; +}; + +template <typename F1, typename F2, typename T> +class SimpleChannelCallbacksImpl final : public SimpleChannelCallbacks { + public: + SimpleChannelCallbacksImpl(F1&& aStartAsyncRead, F2&& aOpenContentStream, + T* context) + : mStartAsyncRead(aStartAsyncRead), + mOpenContentStream(aOpenContentStream), + mContext(context) {} + + virtual ~SimpleChannelCallbacksImpl() = default; + + virtual InputStreamOrReason OpenContentStream(bool async, + nsIChannel* channel) override { + return mOpenContentStream(async, channel, mContext); + } + + virtual RequestOrReason StartAsyncRead(nsIStreamListener* listener, + nsIChannel* channel) override { + return mStartAsyncRead(listener, channel, mContext); + } + + private: + F1 mStartAsyncRead; + F2 mOpenContentStream; + RefPtr<T> mContext; +}; + +class SimpleChannel : public nsBaseChannel { + public: + explicit SimpleChannel(UniquePtr<SimpleChannelCallbacks>&& aCallbacks); + + protected: + virtual ~SimpleChannel() = default; + + virtual nsresult OpenContentStream(bool async, nsIInputStream** streamOut, + nsIChannel** channel) override; + + virtual nsresult BeginAsyncRead(nsIStreamListener* listener, + nsIRequest** request) override; + + private: + UniquePtr<SimpleChannelCallbacks> mCallbacks; +}; + +class SimpleChannelChild final : public SimpleChannel, + public nsIChildChannel, + public PSimpleChannelChild { + public: + explicit SimpleChannelChild(UniquePtr<SimpleChannelCallbacks>&& aCallbacks); + + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_NSICHILDCHANNEL + + private: + virtual ~SimpleChannelChild() = default; +}; + +already_AddRefed<nsIChannel> NS_NewSimpleChannelInternal( + nsIURI* aURI, nsILoadInfo* aLoadInfo, + UniquePtr<SimpleChannelCallbacks>&& aCallbacks); + +} // namespace net +} // namespace mozilla + +/** + * Creates a simple channel which wraps an input stream created by the given + * callbacks. The callbacks are not called until the underlying AsyncOpen or + * Open methods are called, and correspond to the nsBaseChannel::StartAsyncRead + * and nsBaseChannel::OpenContentStream methods of the same names. + * + * The last two arguments of each callback are the created channel instance, + * and the ref-counted context object passed to NS_NewSimpleChannel. A strong + * reference to that object is guaranteed to be kept alive until after a + * callback successfully completes. + */ +template <typename T, typename F1, typename F2> +inline already_AddRefed<nsIChannel> NS_NewSimpleChannel( + nsIURI* aURI, nsILoadInfo* aLoadInfo, T* context, F1&& aStartAsyncRead, + F2&& aOpenContentStream) { + using namespace mozilla; + + auto callbacks = MakeUnique<net::SimpleChannelCallbacksImpl<F1, F2, T>>( + std::move(aStartAsyncRead), std::move(aOpenContentStream), context); + + return net::NS_NewSimpleChannelInternal(aURI, aLoadInfo, + std::move(callbacks)); +} + +template <typename T, typename F1> +inline already_AddRefed<nsIChannel> NS_NewSimpleChannel(nsIURI* aURI, + nsILoadInfo* aLoadInfo, + T* context, + F1&& aStartAsyncRead) { + using namespace mozilla; + + auto openContentStream = [](bool async, nsIChannel* channel, T* context) { + return Err(NS_ERROR_NOT_IMPLEMENTED); + }; + + return NS_NewSimpleChannel(aURI, aLoadInfo, context, + std::move(aStartAsyncRead), + std::move(openContentStream)); +} + +#endif // SimpleChannel_h diff --git a/netwerk/base/SimpleChannelParent.cpp b/netwerk/base/SimpleChannelParent.cpp new file mode 100644 index 0000000000..01029d74eb --- /dev/null +++ b/netwerk/base/SimpleChannelParent.cpp @@ -0,0 +1,97 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=4 sw=2 sts=2 et tw=80: */ +/* 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 "SimpleChannelParent.h" +#include "mozilla/Assertions.h" +#include "nsNetUtil.h" +#include "nsIChannel.h" + +namespace mozilla { +namespace net { + +NS_IMPL_ISUPPORTS(SimpleChannelParent, nsIParentChannel, nsIStreamListener) + +bool SimpleChannelParent::Init(const uint64_t& aChannelId) { + nsCOMPtr<nsIChannel> channel; + MOZ_ALWAYS_SUCCEEDS( + NS_LinkRedirectChannels(aChannelId, this, getter_AddRefs(channel))); + + return true; +} + +NS_IMETHODIMP +SimpleChannelParent::SetParentListener(ParentChannelListener* aListener) { + // Nothing to do. + return NS_OK; +} + +NS_IMETHODIMP +SimpleChannelParent::NotifyClassificationFlags(uint32_t aClassificationFlags, + bool aIsThirdParty) { + // Nothing to do. + return NS_OK; +} + +NS_IMETHODIMP +SimpleChannelParent::NotifyFlashPluginStateChanged( + nsIHttpChannel::FlashPluginState aState) { + // Nothing to do. + return NS_OK; +} + +NS_IMETHODIMP +SimpleChannelParent::SetClassifierMatchedInfo(const nsACString& aList, + const nsACString& aProvider, + const nsACString& aPrefix) { + // nothing to do + return NS_OK; +} + +NS_IMETHODIMP +SimpleChannelParent::SetClassifierMatchedTrackingInfo( + const nsACString& aLists, const nsACString& aFullHashes) { + // nothing to do + return NS_OK; +} + +NS_IMETHODIMP +SimpleChannelParent::Delete() { + // Nothing to do. + return NS_OK; +} + +NS_IMETHODIMP +SimpleChannelParent::GetRemoteType(nsACString& aRemoteType) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +void SimpleChannelParent::ActorDestroy(ActorDestroyReason aWhy) {} + +NS_IMETHODIMP +SimpleChannelParent::OnStartRequest(nsIRequest* aRequest) { + // We don't have a way to prevent nsBaseChannel from calling AsyncOpen on + // the created nsSimpleChannel. We don't have anywhere to send the data in the + // parent, so abort the binding. + return NS_BINDING_ABORTED; +} + +NS_IMETHODIMP +SimpleChannelParent::OnStopRequest(nsIRequest* aRequest, nsresult aStatusCode) { + // See above. + MOZ_ASSERT(NS_FAILED(aStatusCode)); + return NS_OK; +} + +NS_IMETHODIMP +SimpleChannelParent::OnDataAvailable(nsIRequest* aRequest, + nsIInputStream* aInputStream, + uint64_t aOffset, uint32_t aCount) { + // See above. + MOZ_CRASH("Should never be called"); +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/SimpleChannelParent.h b/netwerk/base/SimpleChannelParent.h new file mode 100644 index 0000000000..6a8f2c867b --- /dev/null +++ b/netwerk/base/SimpleChannelParent.h @@ -0,0 +1,40 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=4 sw=2 sts=2 et tw=80: */ +/* 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/. */ + +#ifndef NS_SIMPLECHANNELPARENT_H +#define NS_SIMPLECHANNELPARENT_H + +#include "nsIParentChannel.h" +#include "nsISupportsImpl.h" + +#include "mozilla/net/PSimpleChannelParent.h" + +namespace mozilla { +namespace net { + +// In order to support HTTP redirects, we need to implement the HTTP +// redirection API, which requires a class that implements nsIParentChannel +// and which calls NS_LinkRedirectChannels. +class SimpleChannelParent : public nsIParentChannel, + public PSimpleChannelParent { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIPARENTCHANNEL + NS_DECL_NSIREQUESTOBSERVER + NS_DECL_NSISTREAMLISTENER; // semicolon for clang-format bug 1629756 + + [[nodiscard]] bool Init(const uint64_t& aChannelId); + + private: + ~SimpleChannelParent() = default; + + virtual void ActorDestroy(ActorDestroyReason why) override; +}; + +} // namespace net +} // namespace mozilla + +#endif /* NS_SIMPLECHANNELPARENT_H */ diff --git a/netwerk/base/TCPFastOpen.h b/netwerk/base/TCPFastOpen.h new file mode 100644 index 0000000000..df6fbcc87a --- /dev/null +++ b/netwerk/base/TCPFastOpen.h @@ -0,0 +1,45 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef TCPFASTOPEN_H__ +#define TCPFASTOPEN_H__ + +/** + * This is an abstract class for TCP Fast Open - TFO (RFC7413). + * It is not always safe to use Fast Open. It can be use for requests that + * are replayable. + * Middle boxes can block or reset connections that use TFO, therefore a + * backup connection will be prepared with a delay. + * In case of blocking such a connection tcp socket will terminate only after + * a timeout, therefore a backup connection is needed. If connection is refuse + * the same socketTransport will retry. + * + * This is implemented by nsHalfopenSocket. + **/ + +namespace mozilla { +namespace net { + +class TCPFastOpen { + public: + // Check if we have a transaction that is safe to be used with TFO. + // Connections over TLS are always safe and some http requests (e.g. GET). + virtual bool FastOpenEnabled() = 0; + // To use TFO we need to have a transaction prepared, e.g. also have + // nsHttpConnection ready. This functions is call by nsSocketTransport to + // setup a connection. + virtual nsresult StartFastOpen() = 0; + // Inform nsHalfopenSocket whether a connection using TFO succeeded or not. + // This will cancel the backup connection and in case of a failure rewind + // the transaction. + virtual void SetFastOpenConnected(nsresult error, bool aWillRetry) = 0; + virtual void FastOpenNotSupported() = 0; + virtual void SetFastOpenStatus(uint8_t tfoStatus) = 0; +}; + +} // namespace net +} // namespace mozilla + +#endif // TCPFASTOPEN_H__ diff --git a/netwerk/base/TCPFastOpenLayer.cpp b/netwerk/base/TCPFastOpenLayer.cpp new file mode 100644 index 0000000000..ea5e5f11d6 --- /dev/null +++ b/netwerk/base/TCPFastOpenLayer.cpp @@ -0,0 +1,527 @@ +/* -*- 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 "TCPFastOpenLayer.h" +#include "nsSocketTransportService2.h" +#include "prmem.h" +#include "prio.h" + +namespace mozilla { +namespace net { + +static PRDescIdentity sTCPFastOpenLayerIdentity; +static PRIOMethods sTCPFastOpenLayerMethods; +static PRIOMethods* sTCPFastOpenLayerMethodsPtr = nullptr; + +#define TFO_MAX_PACKET_SIZE_IPV4 1460 +#define TFO_MAX_PACKET_SIZE_IPV6 1440 +#define TFO_TLS_RECORD_HEADER_SIZE 22 + +/** + * For the TCP Fast Open it is necessary to send all data that can fit into the + * first packet on a single sendto function call. Consecutive calls will not + * have an effect. Therefore TCPFastOpenLayer will collect some data before + * calling sendto. Necko and nss will call PR_Write multiple times with small + * amount of data. + * TCPFastOpenLayer has 4 states: + * WAITING_FOR_CONNECT: + * This is before connect is call. A call of recv, send or getpeername will + * return PR_NOT_CONNECTED_ERROR. After connect is call the state transfers + * into COLLECT_DATA_FOR_FIRST_PACKET. + * + * COLLECT_DATA_FOR_FIRST_PACKET: + * In this state all data received by send function calls will be stored in + * a buffer. If transaction do not have any more data ready to be sent or + * the buffer is full, TCPFastOpenFinish is call. TCPFastOpenFinish sends + * the collected data using sendto function and the state transfers to + * WAITING_FOR_CONNECTCONTINUE. If an error occurs during sendto, the error + * is reported by the TCPFastOpenFinish return values. nsSocketTransfer is + * the only caller of TCPFastOpenFinish; it knows how to interpreter these + * errors. + * WAITING_FOR_CONNECTCONTINUE: + * connectcontinue transfers from this state to CONNECTED. Any other + * function (e.g. send, recv) returns PR_WOULD_BLOCK_ERROR. + * CONNECTED: + * The size of mFirstPacketBuf is 1440/1460 (RFC7413 recomends that packet + * does exceeds these sizes). SendTo does not have to consume all buffered + * data and some data can be still in mFirstPacketBuf. Before sending any + * new data we need to send the remaining buffered data. + **/ + +class TCPFastOpenSecret { + public: + TCPFastOpenSecret() + : mState(WAITING_FOR_CONNECT), mFirstPacketBufLen(0), mCondition(0) { + this->mAddr.raw.family = 0; + this->mAddr.inet.family = 0; + this->mAddr.inet.port = 0; + this->mAddr.inet.ip = 0; + this->mAddr.ipv6.family = 0; + this->mAddr.ipv6.port = 0; + this->mAddr.ipv6.flowinfo = 0; + this->mAddr.ipv6.scope_id = 0; + this->mAddr.local.family = 0; + } + + enum { + CONNECTED, + WAITING_FOR_CONNECTCONTINUE, + COLLECT_DATA_FOR_FIRST_PACKET, + WAITING_FOR_CONNECT, + SOCKET_ERROR_STATE + } mState; + PRNetAddr mAddr; + char mFirstPacketBuf[1460]; + uint16_t mFirstPacketBufLen; + PRErrorCode mCondition; +}; + +static PRStatus TCPFastOpenConnect(PRFileDesc* fd, const PRNetAddr* addr, + PRIntervalTime timeout) { + MOZ_RELEASE_ASSERT(fd->identity == sTCPFastOpenLayerIdentity); + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + TCPFastOpenSecret* secret = reinterpret_cast<TCPFastOpenSecret*>(fd->secret); + + SOCKET_LOG(("TCPFastOpenConnect state=%d.\n", secret->mState)); + + if (secret->mState != TCPFastOpenSecret::WAITING_FOR_CONNECT) { + PR_SetError(PR_IS_CONNECTED_ERROR, 0); + return PR_FAILURE; + } + + // Remember the address. It will be used for sendto or connect later. + memcpy(&secret->mAddr, addr, sizeof(secret->mAddr)); + secret->mState = TCPFastOpenSecret::COLLECT_DATA_FOR_FIRST_PACKET; + + return PR_SUCCESS; +} + +static PRInt32 TCPFastOpenSend(PRFileDesc* fd, const void* buf, PRInt32 amount, + PRIntn flags, PRIntervalTime timeout) { + MOZ_RELEASE_ASSERT(fd->identity == sTCPFastOpenLayerIdentity); + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + TCPFastOpenSecret* secret = reinterpret_cast<TCPFastOpenSecret*>(fd->secret); + + SOCKET_LOG(("TCPFastOpenSend state=%d.\n", secret->mState)); + + switch (secret->mState) { + case TCPFastOpenSecret::CONNECTED: + // Before sending new data we need to drain the data collected during tfo. + if (secret->mFirstPacketBufLen) { + SOCKET_LOG( + ("TCPFastOpenSend - %d bytes to drain from " + "mFirstPacketBufLen.\n", + secret->mFirstPacketBufLen)); + PRInt32 rv = (fd->lower->methods->send)( + fd->lower, secret->mFirstPacketBuf, secret->mFirstPacketBufLen, + 0, // flags + PR_INTERVAL_NO_WAIT); + if (rv <= 0) { + return rv; + } + secret->mFirstPacketBufLen -= rv; + if (secret->mFirstPacketBufLen) { + memmove(secret->mFirstPacketBuf, secret->mFirstPacketBuf + rv, + secret->mFirstPacketBufLen); + + PR_SetError(PR_WOULD_BLOCK_ERROR, 0); + return PR_FAILURE; + } // if we drained the buffer we can fall through this checks and call + // send for the new data + } + SOCKET_LOG(("TCPFastOpenSend sending new data.\n")); + return (fd->lower->methods->send)(fd->lower, buf, amount, flags, timeout); + case TCPFastOpenSecret::WAITING_FOR_CONNECTCONTINUE: + PR_SetError(PR_WOULD_BLOCK_ERROR, 0); + return -1; + case TCPFastOpenSecret::COLLECT_DATA_FOR_FIRST_PACKET: { + int32_t toSend = (secret->mAddr.raw.family == PR_AF_INET) + ? TFO_MAX_PACKET_SIZE_IPV4 + : TFO_MAX_PACKET_SIZE_IPV6; + MOZ_ASSERT(secret->mFirstPacketBufLen <= toSend); + toSend -= secret->mFirstPacketBufLen; + + SOCKET_LOG( + ("TCPFastOpenSend: amount of data in the buffer=%d; the amount" + " of additional data that can be stored=%d.\n", + secret->mFirstPacketBufLen, toSend)); + + if (!toSend) { + PR_SetError(PR_WOULD_BLOCK_ERROR, 0); + return -1; + } + + toSend = (toSend > amount) ? amount : toSend; + memcpy(secret->mFirstPacketBuf + secret->mFirstPacketBufLen, buf, toSend); + secret->mFirstPacketBufLen += toSend; + return toSend; + } + case TCPFastOpenSecret::WAITING_FOR_CONNECT: + PR_SetError(PR_NOT_CONNECTED_ERROR, 0); + return -1; + case TCPFastOpenSecret::SOCKET_ERROR_STATE: + PR_SetError(secret->mCondition, 0); + return -1; + } + PR_SetError(PR_WOULD_BLOCK_ERROR, 0); + return PR_FAILURE; +} + +static PRInt32 TCPFastOpenWrite(PRFileDesc* fd, const void* buf, + PRInt32 amount) { + return TCPFastOpenSend(fd, buf, amount, 0, PR_INTERVAL_NO_WAIT); +} + +static PRInt32 TCPFastOpenRecv(PRFileDesc* fd, void* buf, PRInt32 amount, + PRIntn flags, PRIntervalTime timeout) { + MOZ_RELEASE_ASSERT(fd->identity == sTCPFastOpenLayerIdentity); + + TCPFastOpenSecret* secret = reinterpret_cast<TCPFastOpenSecret*>(fd->secret); + + PRInt32 rv = -1; + switch (secret->mState) { + case TCPFastOpenSecret::CONNECTED: + + if (secret->mFirstPacketBufLen) { + // TLS will not call write before receiving data from a server, + // therefore we need to force sending buffered data even during recv + // call. Otherwise It can come to a deadlock (clients waits for + // response, but the request is sitting in mFirstPacketBufLen). + SOCKET_LOG( + ("TCPFastOpenRevc - %d bytes to drain from mFirstPacketBuf.\n", + secret->mFirstPacketBufLen)); + PRInt32 rv = (fd->lower->methods->send)( + fd->lower, secret->mFirstPacketBuf, secret->mFirstPacketBufLen, + 0, // flags + PR_INTERVAL_NO_WAIT); + if (rv <= 0) { + return rv; + } + secret->mFirstPacketBufLen -= rv; + if (secret->mFirstPacketBufLen) { + memmove(secret->mFirstPacketBuf, secret->mFirstPacketBuf + rv, + secret->mFirstPacketBufLen); + } + } + rv = (fd->lower->methods->recv)(fd->lower, buf, amount, flags, timeout); + break; + case TCPFastOpenSecret::WAITING_FOR_CONNECTCONTINUE: + case TCPFastOpenSecret::COLLECT_DATA_FOR_FIRST_PACKET: + PR_SetError(PR_WOULD_BLOCK_ERROR, 0); + break; + case TCPFastOpenSecret::WAITING_FOR_CONNECT: + PR_SetError(PR_NOT_CONNECTED_ERROR, 0); + break; + case TCPFastOpenSecret::SOCKET_ERROR_STATE: + PR_SetError(secret->mCondition, 0); + } + return rv; +} + +static PRInt32 TCPFastOpenRead(PRFileDesc* fd, void* buf, PRInt32 amount) { + return TCPFastOpenRecv(fd, buf, amount, 0, PR_INTERVAL_NO_WAIT); +} + +static PRStatus TCPFastOpenConnectContinue(PRFileDesc* fd, PRInt16 out_flags) { + MOZ_RELEASE_ASSERT(fd->identity == sTCPFastOpenLayerIdentity); + + TCPFastOpenSecret* secret = reinterpret_cast<TCPFastOpenSecret*>(fd->secret); + + PRStatus rv = PR_FAILURE; + switch (secret->mState) { + case TCPFastOpenSecret::CONNECTED: + rv = PR_SUCCESS; + break; + case TCPFastOpenSecret::WAITING_FOR_CONNECT: + case TCPFastOpenSecret::COLLECT_DATA_FOR_FIRST_PACKET: + PR_SetError(PR_NOT_CONNECTED_ERROR, 0); + rv = PR_FAILURE; + break; + case TCPFastOpenSecret::WAITING_FOR_CONNECTCONTINUE: + rv = (fd->lower->methods->connectcontinue)(fd->lower, out_flags); + + SOCKET_LOG(("TCPFastOpenConnectContinue result=%d.\n", rv)); + secret->mState = TCPFastOpenSecret::CONNECTED; + break; + case TCPFastOpenSecret::SOCKET_ERROR_STATE: + PR_SetError(secret->mCondition, 0); + rv = PR_FAILURE; + } + return rv; +} + +static PRStatus TCPFastOpenClose(PRFileDesc* fd) { + if (!fd) { + return PR_FAILURE; + } + + PRFileDesc* layer = PR_PopIOLayer(fd, PR_TOP_IO_LAYER); + + MOZ_RELEASE_ASSERT(layer && layer->identity == sTCPFastOpenLayerIdentity, + "TCP Fast Open Layer not on top of stack"); + + TCPFastOpenSecret* secret = + reinterpret_cast<TCPFastOpenSecret*>(layer->secret); + layer->secret = nullptr; + layer->dtor(layer); + delete secret; + return fd->methods->close(fd); +} + +static PRStatus TCPFastOpenGetpeername(PRFileDesc* fd, PRNetAddr* addr) { + MOZ_RELEASE_ASSERT(fd); + MOZ_RELEASE_ASSERT(addr); + + MOZ_RELEASE_ASSERT(fd->identity == sTCPFastOpenLayerIdentity); + + TCPFastOpenSecret* secret = reinterpret_cast<TCPFastOpenSecret*>(fd->secret); + if (secret->mState == TCPFastOpenSecret::WAITING_FOR_CONNECT) { + PR_SetError(PR_NOT_CONNECTED_ERROR, 0); + return PR_FAILURE; + } + + memcpy(addr, &secret->mAddr, sizeof(secret->mAddr)); + return PR_SUCCESS; +} + +static PRInt16 TCPFastOpenPoll(PRFileDesc* fd, PRInt16 how_flags, + PRInt16* p_out_flags) { + MOZ_RELEASE_ASSERT(fd); + MOZ_RELEASE_ASSERT(fd->identity == sTCPFastOpenLayerIdentity); + + TCPFastOpenSecret* secret = reinterpret_cast<TCPFastOpenSecret*>(fd->secret); + if (secret->mFirstPacketBufLen) { + how_flags |= PR_POLL_WRITE; + } + + return fd->lower->methods->poll(fd->lower, how_flags, p_out_flags); +} + +nsresult AttachTCPFastOpenIOLayer(PRFileDesc* fd) { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + if (!sTCPFastOpenLayerMethodsPtr) { + sTCPFastOpenLayerIdentity = PR_GetUniqueIdentity("TCPFastOpen Layer"); + sTCPFastOpenLayerMethods = *PR_GetDefaultIOMethods(); + sTCPFastOpenLayerMethods.connect = TCPFastOpenConnect; + sTCPFastOpenLayerMethods.send = TCPFastOpenSend; + sTCPFastOpenLayerMethods.write = TCPFastOpenWrite; + sTCPFastOpenLayerMethods.recv = TCPFastOpenRecv; + sTCPFastOpenLayerMethods.read = TCPFastOpenRead; + sTCPFastOpenLayerMethods.connectcontinue = TCPFastOpenConnectContinue; + sTCPFastOpenLayerMethods.close = TCPFastOpenClose; + sTCPFastOpenLayerMethods.getpeername = TCPFastOpenGetpeername; + sTCPFastOpenLayerMethods.poll = TCPFastOpenPoll; + sTCPFastOpenLayerMethodsPtr = &sTCPFastOpenLayerMethods; + } + + PRFileDesc* layer = PR_CreateIOLayerStub(sTCPFastOpenLayerIdentity, + sTCPFastOpenLayerMethodsPtr); + + if (!layer) { + return NS_ERROR_FAILURE; + } + + TCPFastOpenSecret* secret = new TCPFastOpenSecret(); + + layer->secret = reinterpret_cast<PRFilePrivate*>(secret); + + PRStatus status = PR_PushIOLayer(fd, PR_NSPR_IO_LAYER, layer); + + if (status == PR_FAILURE) { + delete secret; + PR_Free(layer); // PR_CreateIOLayerStub() uses PR_Malloc(). + return NS_ERROR_FAILURE; + } + return NS_OK; +} + +void TCPFastOpenFinish(PRFileDesc* fd, PRErrorCode& err, + bool& fastOpenNotSupported, uint8_t& tfoStatus) { + PRFileDesc* tfoFd = PR_GetIdentitiesLayer(fd, sTCPFastOpenLayerIdentity); + MOZ_RELEASE_ASSERT(tfoFd); + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + TCPFastOpenSecret* secret = + reinterpret_cast<TCPFastOpenSecret*>(tfoFd->secret); + + MOZ_ASSERT(secret->mState == + TCPFastOpenSecret::COLLECT_DATA_FOR_FIRST_PACKET); + + fastOpenNotSupported = false; + tfoStatus = TFO_NOT_TRIED; + PRErrorCode result = 0; + + // If we do not have data to send with syn packet or nspr version does not + // have sendto implemented we will call normal connect. + // If sendto is not implemented it points to _PR_InvalidInt, therefore we + // check if sendto != _PR_InvalidInt. _PR_InvalidInt is exposed so we use + // reserved_fn_0 which also points to _PR_InvalidInt. + if (!secret->mFirstPacketBufLen || + (tfoFd->lower->methods->sendto == + (PRSendtoFN)tfoFd->lower->methods->reserved_fn_0)) { + // Because of the way our nsHttpTransaction dispatch work, it can happened + // that data has not been written into the socket. + // In this case we can just call connect. + PRInt32 rv = (tfoFd->lower->methods->connect)(tfoFd->lower, &secret->mAddr, + PR_INTERVAL_NO_WAIT); + if (rv == PR_SUCCESS) { + result = PR_IS_CONNECTED_ERROR; + } else { + result = PR_GetError(); + } + if (tfoFd->lower->methods->sendto == + (PRSendtoFN)tfoFd->lower->methods->reserved_fn_0) { + // sendto is not implemented, it is equal to _PR_InvalidInt! + // We will disable Fast Open. + SOCKET_LOG(("TCPFastOpenFinish - sendto not implemented.\n")); + fastOpenNotSupported = true; + tfoStatus = TFO_DISABLED; + } + } else { + // We have some data ready in the buffer we will send it with the syn + // packet. + PRInt32 rv = (tfoFd->lower->methods->sendto)( + tfoFd->lower, secret->mFirstPacketBuf, secret->mFirstPacketBufLen, + 0, // flags + &secret->mAddr, PR_INTERVAL_NO_WAIT); + + SOCKET_LOG(("TCPFastOpenFinish - sendto result=%d.\n", rv)); + if (rv > 0) { + result = PR_IN_PROGRESS_ERROR; + secret->mFirstPacketBufLen -= rv; + if (secret->mFirstPacketBufLen) { + memmove(secret->mFirstPacketBuf, secret->mFirstPacketBuf + rv, + secret->mFirstPacketBufLen); + } + tfoStatus = TFO_DATA_SENT; + } else { + result = PR_GetError(); + SOCKET_LOG(("TCPFastOpenFinish - sendto error=%d.\n", result)); + + if (result == + PR_NOT_TCP_SOCKET_ERROR) { // SendTo will return + // PR_NOT_TCP_SOCKET_ERROR if TCP Fast + // Open is turned off on Linux. + // We can call connect again. + fastOpenNotSupported = true; + rv = (tfoFd->lower->methods->connect)(tfoFd->lower, &secret->mAddr, + PR_INTERVAL_NO_WAIT); + + if (rv == PR_SUCCESS) { + result = PR_IS_CONNECTED_ERROR; + } else { + result = PR_GetError(); + } + tfoStatus = TFO_DISABLED; + } else { + tfoStatus = TFO_TRIED; + } + } + } + + if (result == PR_IN_PROGRESS_ERROR) { + secret->mState = TCPFastOpenSecret::WAITING_FOR_CONNECTCONTINUE; + } else { + // If the error is not PR_IN_PROGRESS_ERROR, change the state to CONNECT so + // that recv/send can perform recv/send on the next lower layer and pick up + // the real error. This is really important! + // The result can also be PR_IS_CONNECTED_ERROR, that should change the + // state to CONNECT anyway. + secret->mState = TCPFastOpenSecret::CONNECTED; + } + err = result; +} + +/* This function returns the size of the remaining free space in the + * first_packet_buffer. This will be used by transactions with a tls layer. For + * other transactions it is not necessary. The tls transactions make a tls + * record before writing to this layer and if the record is too big the part + * that does not have place in the mFirstPacketBuf will be saved on the tls + * layer. During TFO we cannot send more than TFO_MAX_PACKET_SIZE_IPV4/6 bytes, + * so if we have a big tls record, this record is encrypted with 0RTT key, + * tls-early-data can be rejected and than we still need to send the rest of the + * record. + */ +int32_t TCPFastOpenGetBufferSizeLeft(PRFileDesc* fd) { + PRFileDesc* tfoFd = PR_GetIdentitiesLayer(fd, sTCPFastOpenLayerIdentity); + MOZ_RELEASE_ASSERT(tfoFd); + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + TCPFastOpenSecret* secret = + reinterpret_cast<TCPFastOpenSecret*>(tfoFd->secret); + + if (secret->mState != TCPFastOpenSecret::COLLECT_DATA_FOR_FIRST_PACKET) { + return 0; + } + + int32_t sizeLeft = (secret->mAddr.raw.family == PR_AF_INET) + ? TFO_MAX_PACKET_SIZE_IPV4 + : TFO_MAX_PACKET_SIZE_IPV6; + MOZ_ASSERT(secret->mFirstPacketBufLen <= sizeLeft); + sizeLeft -= secret->mFirstPacketBufLen; + + SOCKET_LOG(("TCPFastOpenGetBufferSizeLeft=%d.\n", sizeLeft)); + + return (sizeLeft > TFO_TLS_RECORD_HEADER_SIZE) + ? sizeLeft - TFO_TLS_RECORD_HEADER_SIZE + : 0; +} + +bool TCPFastOpenGetCurrentBufferSize(PRFileDesc* fd) { + PRFileDesc* tfoFd = PR_GetIdentitiesLayer(fd, sTCPFastOpenLayerIdentity); + MOZ_RELEASE_ASSERT(tfoFd); + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + TCPFastOpenSecret* secret = + reinterpret_cast<TCPFastOpenSecret*>(tfoFd->secret); + + return secret->mFirstPacketBufLen; +} + +bool TCPFastOpenFlushBuffer(PRFileDesc* fd) { + PRFileDesc* tfoFd = PR_GetIdentitiesLayer(fd, sTCPFastOpenLayerIdentity); + MOZ_RELEASE_ASSERT(tfoFd); + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + TCPFastOpenSecret* secret = + reinterpret_cast<TCPFastOpenSecret*>(tfoFd->secret); + MOZ_ASSERT(secret->mState == TCPFastOpenSecret::CONNECTED); + + if (secret->mFirstPacketBufLen) { + SOCKET_LOG( + ("TCPFastOpenFlushBuffer - %d bytes to drain from " + "mFirstPacketBufLen.\n", + secret->mFirstPacketBufLen)); + PRInt32 rv = (tfoFd->lower->methods->send)( + tfoFd->lower, secret->mFirstPacketBuf, secret->mFirstPacketBufLen, + 0, // flags + PR_INTERVAL_NO_WAIT); + if (rv <= 0) { + PRErrorCode err = PR_GetError(); + if (err == PR_WOULD_BLOCK_ERROR) { + // We still need to send this data. + return true; + } + // There is an error, let nsSocketTransport pick it up properly. + secret->mCondition = err; + secret->mState = TCPFastOpenSecret::SOCKET_ERROR_STATE; + return false; + } + + secret->mFirstPacketBufLen -= rv; + if (secret->mFirstPacketBufLen) { + memmove(secret->mFirstPacketBuf, secret->mFirstPacketBuf + rv, + secret->mFirstPacketBufLen); + } + } + return secret->mFirstPacketBufLen; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/TCPFastOpenLayer.h b/netwerk/base/TCPFastOpenLayer.h new file mode 100644 index 0000000000..597615cabe --- /dev/null +++ b/netwerk/base/TCPFastOpenLayer.h @@ -0,0 +1,94 @@ +/* -*- 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/. */ + +#ifndef TCPFastOpenLayer_h__ +#define TCPFastOpenLayer_h__ + +#include "prerror.h" + +namespace mozilla { +namespace net { + +/** + * This layer must be placed just above PR-tcp socket, i.e. it must be under + * nss layer. + * At the beginning of TCPFastOpenLayer.cpp there is explanation what this + * layer do. + **/ + +typedef enum { + TFO_NOT_SET, // This is only as a control. + // A connection not using TFO will have the TFO state set upon + // connection creation (in nsHalfOpenSocket::SetupConn). + // A connection using TFO will have the TFO state set after + // the connection is established or canceled. + TFO_UNKNOWN, // This is before the primary socket is built, i.e. before + // TCPFastOpenFinish is called. + TFO_DISABLED, // tfo is disabled because of a tfo error on a previous + // connection to the host (i.e. !mEnt->mUseFastOpen). + // If TFO is not supported by the OS, it is disabled by + // the pref or too many consecutive errors occurred, this value + // is not reported. This is set before StartFastOpen is called. + TFO_DISABLED_CONNECT, // Connection is using CONNECT. This is set before + // StartFastOpen is called. + // The following 3 are set just after TCPFastOpenFinish. + TFO_NOT_TRIED, // For some reason TCPFastOpenLayer does not have any data to + // send with the syn packet. This should never happen. + TFO_TRIED, // TCP has sent a TFO cookie request. + TFO_DATA_SENT, // On Linux, TCP has send data as well. (On Linux we do not + // know whether data has been accepted). + // On Windows, TCP has send data or only a TFO cookie request + // and the data or TFO cookie has been accepted by the server. + // The following value is only used on windows and is set after + // PR_ConnectContinue. That is the point when we know if TFO data was been + // accepted. + TFO_DATA_COOKIE_NOT_ACCEPTED, // This is only on Windows. TFO data or TFO + // cookie request has not been accepted. + // The following 3 are set during socket error recover + // (nsSocketTransport::RecoverFromError). + TFO_FAILED_CONNECTION_REFUSED, + TFO_FAILED_NET_TIMEOUT, + TFO_FAILED_UNKNOW_ERROR, + // The following 4 are set when backup connection finishes before the primary + // connection. + TFO_FAILED_BACKUP_CONNECTION_TFO_NOT_TRIED, + TFO_FAILED_BACKUP_CONNECTION_TFO_TRIED, + TFO_FAILED_BACKUP_CONNECTION_TFO_DATA_SENT, + TFO_FAILED_BACKUP_CONNECTION_TFO_DATA_COOKIE_NOT_ACCEPTED, + // The following 4 are set when the recovery connection fails as well. + TFO_FAILED_CONNECTION_REFUSED_NO_TFO_FAILED_TOO, + TFO_FAILED_NET_TIMEOUT_NO_TFO_FAILED_TOO, + TFO_FAILED_UNKNOW_ERROR_NO_TFO_FAILED_TOO, + TFO_FAILED_BACKUP_CONNECTION_NO_TFO_FAILED_TOO, + TFO_BACKUP_CONN, // This is a backup conn, for a halfOpenSock that was used + // TFO. + TFO_INIT_FAILED, // nsHalfOpenSocket::SetupConn failed. + TFO_UNKNOWN_RESOLVING, // There is a high number of TFO_UNKNOWN state + // reported. Let's split them depending on the socket + // transport state: TFO_UNKNOWN_RESOLVING, + // TFO_UNKNOWN_RESOLVED, TFO_UNKNOWN_CONNECTING and + // TFO_UNKNOWN_CONNECTED.. + TFO_UNKNOWN_RESOLVED, + TFO_UNKNOWN_CONNECTING, + TFO_UNKNOWN_CONNECTED, + TFO_FAILED, + TFO_HTTP // TFO is disabled for non-secure connections. +} TFOResult; + +nsresult AttachTCPFastOpenIOLayer(PRFileDesc* fd); + +// Get the result of TCP Fast Open. +void TCPFastOpenFinish(PRFileDesc* fd, PRErrorCode& err, + bool& fastOpenNotSupported, uint8_t& tfoStatus); + +int32_t TCPFastOpenGetBufferSizeLeft(PRFileDesc* fd); + +bool TCPFastOpenGetCurrentBufferSize(PRFileDesc* fd); +bool TCPFastOpenFlushBuffer(PRFileDesc* fd); +} // namespace net +} // namespace mozilla + +#endif // TCPFastOpenLayer_h__ diff --git a/netwerk/base/TLSServerSocket.cpp b/netwerk/base/TLSServerSocket.cpp new file mode 100644 index 0000000000..ff4049b316 --- /dev/null +++ b/netwerk/base/TLSServerSocket.cpp @@ -0,0 +1,448 @@ +/* vim:set ts=2 sw=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 "TLSServerSocket.h" + +#include "mozilla/net/DNS.h" +#include "nsComponentManagerUtils.h" +#include "nsDependentSubstring.h" +#include "nsIServerSocket.h" +#include "nsIX509Cert.h" +#include "nsIX509CertDB.h" +#include "nsNetCID.h" +#include "nsProxyRelease.h" +#include "nsServiceManagerUtils.h" +#include "nsSocketTransport2.h" +#include "nsThreadUtils.h" +#include "ScopedNSSTypes.h" +#include "ssl.h" + +namespace mozilla { +namespace net { + +//----------------------------------------------------------------------------- +// TLSServerSocket +//----------------------------------------------------------------------------- + +TLSServerSocket::TLSServerSocket() : mServerCert(nullptr) {} + +NS_IMPL_ISUPPORTS_INHERITED(TLSServerSocket, nsServerSocket, nsITLSServerSocket) + +nsresult TLSServerSocket::SetSocketDefaults() { + // Set TLS options on the listening socket + mFD = SSL_ImportFD(nullptr, mFD); + if (NS_WARN_IF(!mFD)) { + return mozilla::psm::GetXPCOMFromNSSError(PR_GetError()); + } + + SSL_OptionSet(mFD, SSL_SECURITY, true); + SSL_OptionSet(mFD, SSL_HANDSHAKE_AS_CLIENT, false); + SSL_OptionSet(mFD, SSL_HANDSHAKE_AS_SERVER, true); + SSL_OptionSet(mFD, SSL_NO_CACHE, true); + + // We don't currently notify the server API consumer of renegotiation events + // (to revalidate peer certs, etc.), so disable it for now. + SSL_OptionSet(mFD, SSL_ENABLE_RENEGOTIATION, SSL_RENEGOTIATE_NEVER); + + SetSessionTickets(true); + SetRequestClientCertificate(REQUEST_NEVER); + + return NS_OK; +} + +void TLSServerSocket::CreateClientTransport(PRFileDesc* aClientFD, + const NetAddr& aClientAddr) { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + nsresult rv; + + RefPtr<nsSocketTransport> trans = new nsSocketTransport; + if (NS_WARN_IF(!trans)) { + mCondition = NS_ERROR_OUT_OF_MEMORY; + return; + } + + RefPtr<TLSServerConnectionInfo> info = new TLSServerConnectionInfo(); + info->mServerSocket = this; + info->mTransport = trans; + nsCOMPtr<nsISupports> infoSupports = + NS_ISUPPORTS_CAST(nsITLSServerConnectionInfo*, info); + rv = trans->InitWithConnectedSocket(aClientFD, &aClientAddr, infoSupports); + if (NS_WARN_IF(NS_FAILED(rv))) { + mCondition = rv; + return; + } + + // Override the default peer certificate validation, so that server consumers + // can make their own choice after the handshake completes. + SSL_AuthCertificateHook(aClientFD, AuthCertificateHook, nullptr); + // Once the TLS handshake has completed, the server consumer is notified and + // has access to various TLS state details. + // It's safe to pass info here because the socket transport holds it as + // |mSecInfo| which keeps it alive for the lifetime of the socket. + SSL_HandshakeCallback(aClientFD, TLSServerConnectionInfo::HandshakeCallback, + info); + + // Notify the consumer of the new client so it can manage the streams. + // Security details aren't known yet. The security observer will be notified + // later when they are ready. + nsCOMPtr<nsIServerSocket> serverSocket = + do_QueryInterface(NS_ISUPPORTS_CAST(nsITLSServerSocket*, this)); + mListener->OnSocketAccepted(serverSocket, trans); +} + +nsresult TLSServerSocket::OnSocketListen() { + if (NS_WARN_IF(!mServerCert)) { + return NS_ERROR_NOT_INITIALIZED; + } + + UniqueCERTCertificate cert(mServerCert->GetCert()); + if (NS_WARN_IF(!cert)) { + return mozilla::psm::GetXPCOMFromNSSError(PR_GetError()); + } + + UniqueSECKEYPrivateKey key(PK11_FindKeyByAnyCert(cert.get(), nullptr)); + if (NS_WARN_IF(!key)) { + return mozilla::psm::GetXPCOMFromNSSError(PR_GetError()); + } + + SSLKEAType certKEA = NSS_FindCertKEAType(cert.get()); + + nsresult rv = + MapSECStatus(SSL_ConfigSecureServer(mFD, cert.get(), key.get(), certKEA)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + return NS_OK; +} + +// static +SECStatus TLSServerSocket::AuthCertificateHook(void* arg, PRFileDesc* fd, + PRBool checksig, + PRBool isServer) { + // Allow any client cert here, server consumer code can decide whether it's + // okay after being notified of the new client socket. + return SECSuccess; +} + +//----------------------------------------------------------------------------- +// TLSServerSocket::nsITLSServerSocket +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +TLSServerSocket::GetServerCert(nsIX509Cert** aCert) { + if (NS_WARN_IF(!aCert)) { + return NS_ERROR_INVALID_POINTER; + } + *aCert = mServerCert; + NS_IF_ADDREF(*aCert); + return NS_OK; +} + +NS_IMETHODIMP +TLSServerSocket::SetServerCert(nsIX509Cert* aCert) { + // If AsyncListen was already called (and set mListener), it's too late to set + // this. + if (NS_WARN_IF(mListener)) { + return NS_ERROR_IN_PROGRESS; + } + mServerCert = aCert; + return NS_OK; +} + +NS_IMETHODIMP +TLSServerSocket::SetSessionTickets(bool aEnabled) { + // If AsyncListen was already called (and set mListener), it's too late to set + // this. + if (NS_WARN_IF(mListener)) { + return NS_ERROR_IN_PROGRESS; + } + SSL_OptionSet(mFD, SSL_ENABLE_SESSION_TICKETS, aEnabled); + return NS_OK; +} + +NS_IMETHODIMP +TLSServerSocket::SetRequestClientCertificate(uint32_t aMode) { + // If AsyncListen was already called (and set mListener), it's too late to set + // this. + if (NS_WARN_IF(mListener)) { + return NS_ERROR_IN_PROGRESS; + } + SSL_OptionSet(mFD, SSL_REQUEST_CERTIFICATE, aMode != REQUEST_NEVER); + + switch (aMode) { + case REQUEST_ALWAYS: + SSL_OptionSet(mFD, SSL_REQUIRE_CERTIFICATE, SSL_REQUIRE_NO_ERROR); + break; + case REQUIRE_FIRST_HANDSHAKE: + SSL_OptionSet(mFD, SSL_REQUIRE_CERTIFICATE, SSL_REQUIRE_FIRST_HANDSHAKE); + break; + case REQUIRE_ALWAYS: + SSL_OptionSet(mFD, SSL_REQUIRE_CERTIFICATE, SSL_REQUIRE_ALWAYS); + break; + default: + SSL_OptionSet(mFD, SSL_REQUIRE_CERTIFICATE, SSL_REQUIRE_NEVER); + } + return NS_OK; +} + +NS_IMETHODIMP +TLSServerSocket::SetVersionRange(uint16_t aMinVersion, uint16_t aMaxVersion) { + // If AsyncListen was already called (and set mListener), it's too late to set + // this. + if (NS_WARN_IF(mListener)) { + return NS_ERROR_IN_PROGRESS; + } + + SSLVersionRange range = {aMinVersion, aMaxVersion}; + if (SSL_VersionRangeSet(mFD, &range) != SECSuccess) { + return mozilla::psm::GetXPCOMFromNSSError(PR_GetError()); + } + + return NS_OK; +} + +//----------------------------------------------------------------------------- +// TLSServerConnectionInfo +//----------------------------------------------------------------------------- + +namespace { + +class TLSServerSecurityObserverProxy final + : public nsITLSServerSecurityObserver { + ~TLSServerSecurityObserverProxy() = default; + + public: + explicit TLSServerSecurityObserverProxy( + nsITLSServerSecurityObserver* aListener) + : mListener(new nsMainThreadPtrHolder<nsITLSServerSecurityObserver>( + "TLSServerSecurityObserverProxy::mListener", aListener)) {} + + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSITLSSERVERSECURITYOBSERVER + + class OnHandshakeDoneRunnable : public Runnable { + public: + OnHandshakeDoneRunnable( + const nsMainThreadPtrHandle<nsITLSServerSecurityObserver>& aListener, + nsITLSServerSocket* aServer, nsITLSClientStatus* aStatus) + : Runnable( + "net::TLSServerSecurityObserverProxy::OnHandshakeDoneRunnable"), + mListener(aListener), + mServer(aServer), + mStatus(aStatus) {} + + NS_DECL_NSIRUNNABLE + + private: + nsMainThreadPtrHandle<nsITLSServerSecurityObserver> mListener; + nsCOMPtr<nsITLSServerSocket> mServer; + nsCOMPtr<nsITLSClientStatus> mStatus; + }; + + private: + nsMainThreadPtrHandle<nsITLSServerSecurityObserver> mListener; +}; + +NS_IMPL_ISUPPORTS(TLSServerSecurityObserverProxy, nsITLSServerSecurityObserver) + +NS_IMETHODIMP +TLSServerSecurityObserverProxy::OnHandshakeDone(nsITLSServerSocket* aServer, + nsITLSClientStatus* aStatus) { + RefPtr<OnHandshakeDoneRunnable> r = + new OnHandshakeDoneRunnable(mListener, aServer, aStatus); + return NS_DispatchToMainThread(r); +} + +NS_IMETHODIMP +TLSServerSecurityObserverProxy::OnHandshakeDoneRunnable::Run() { + mListener->OnHandshakeDone(mServer, mStatus); + return NS_OK; +} + +} // namespace + +NS_IMPL_ISUPPORTS(TLSServerConnectionInfo, nsITLSServerConnectionInfo, + nsITLSClientStatus) + +TLSServerConnectionInfo::TLSServerConnectionInfo() + : mServerSocket(nullptr), + mTransport(nullptr), + mPeerCert(nullptr), + mTlsVersionUsed(TLS_VERSION_UNKNOWN), + mKeyLength(0), + mMacLength(0), + mLock("TLSServerConnectionInfo.mLock"), + mSecurityObserver(nullptr) {} + +TLSServerConnectionInfo::~TLSServerConnectionInfo() { + RefPtr<nsITLSServerSecurityObserver> observer; + { + MutexAutoLock lock(mLock); + observer = ToRefPtr(std::move(mSecurityObserver)); + } + + if (observer) { + NS_ReleaseOnMainThread("TLSServerConnectionInfo::mSecurityObserver", + observer.forget()); + } +} + +NS_IMETHODIMP +TLSServerConnectionInfo::SetSecurityObserver( + nsITLSServerSecurityObserver* aObserver) { + { + MutexAutoLock lock(mLock); + if (!aObserver) { + mSecurityObserver = nullptr; + return NS_OK; + } + + mSecurityObserver = new TLSServerSecurityObserverProxy(aObserver); + // Call `OnHandshakeDone` if TLS handshake is already completed. + if (mTlsVersionUsed != TLS_VERSION_UNKNOWN) { + nsCOMPtr<nsITLSServerSocket> serverSocket; + GetServerSocket(getter_AddRefs(serverSocket)); + mSecurityObserver->OnHandshakeDone(serverSocket, this); + mSecurityObserver = nullptr; + } + } + return NS_OK; +} + +NS_IMETHODIMP +TLSServerConnectionInfo::GetServerSocket(nsITLSServerSocket** aSocket) { + if (NS_WARN_IF(!aSocket)) { + return NS_ERROR_INVALID_POINTER; + } + *aSocket = mServerSocket; + NS_IF_ADDREF(*aSocket); + return NS_OK; +} + +NS_IMETHODIMP +TLSServerConnectionInfo::GetStatus(nsITLSClientStatus** aStatus) { + if (NS_WARN_IF(!aStatus)) { + return NS_ERROR_INVALID_POINTER; + } + *aStatus = this; + NS_IF_ADDREF(*aStatus); + return NS_OK; +} + +NS_IMETHODIMP +TLSServerConnectionInfo::GetPeerCert(nsIX509Cert** aCert) { + if (NS_WARN_IF(!aCert)) { + return NS_ERROR_INVALID_POINTER; + } + *aCert = mPeerCert; + NS_IF_ADDREF(*aCert); + return NS_OK; +} + +NS_IMETHODIMP +TLSServerConnectionInfo::GetTlsVersionUsed(int16_t* aTlsVersionUsed) { + if (NS_WARN_IF(!aTlsVersionUsed)) { + return NS_ERROR_INVALID_POINTER; + } + *aTlsVersionUsed = mTlsVersionUsed; + return NS_OK; +} + +NS_IMETHODIMP +TLSServerConnectionInfo::GetCipherName(nsACString& aCipherName) { + aCipherName.Assign(mCipherName); + return NS_OK; +} + +NS_IMETHODIMP +TLSServerConnectionInfo::GetKeyLength(uint32_t* aKeyLength) { + if (NS_WARN_IF(!aKeyLength)) { + return NS_ERROR_INVALID_POINTER; + } + *aKeyLength = mKeyLength; + return NS_OK; +} + +NS_IMETHODIMP +TLSServerConnectionInfo::GetMacLength(uint32_t* aMacLength) { + if (NS_WARN_IF(!aMacLength)) { + return NS_ERROR_INVALID_POINTER; + } + *aMacLength = mMacLength; + return NS_OK; +} + +// static +void TLSServerConnectionInfo::HandshakeCallback(PRFileDesc* aFD, void* aArg) { + RefPtr<TLSServerConnectionInfo> info = + static_cast<TLSServerConnectionInfo*>(aArg); + nsISocketTransport* transport = info->mTransport; + // No longer needed outside this function, so clear the weak ref + info->mTransport = nullptr; + nsresult rv = info->HandshakeCallback(aFD); + if (NS_WARN_IF(NS_FAILED(rv))) { + transport->Close(rv); + } +} + +nsresult TLSServerConnectionInfo::HandshakeCallback(PRFileDesc* aFD) { + nsresult rv; + + UniqueCERTCertificate clientCert(SSL_PeerCertificate(aFD)); + if (clientCert) { + nsCOMPtr<nsIX509CertDB> certDB = + do_GetService(NS_X509CERTDB_CONTRACTID, &rv); + if (NS_FAILED(rv)) { + return rv; + } + + nsCOMPtr<nsIX509Cert> clientCertPSM; + nsTArray<uint8_t> clientCertBytes; + clientCertBytes.AppendElements(clientCert->derCert.data, + clientCert->derCert.len); + rv = certDB->ConstructX509(clientCertBytes, getter_AddRefs(clientCertPSM)); + if (NS_FAILED(rv)) { + return rv; + } + + mPeerCert = clientCertPSM; + } + + SSLChannelInfo channelInfo; + rv = MapSECStatus(SSL_GetChannelInfo(aFD, &channelInfo, sizeof(channelInfo))); + if (NS_FAILED(rv)) { + return rv; + } + + SSLCipherSuiteInfo cipherInfo; + rv = MapSECStatus(SSL_GetCipherSuiteInfo(channelInfo.cipherSuite, &cipherInfo, + sizeof(cipherInfo))); + if (NS_FAILED(rv)) { + return rv; + } + mCipherName.Assign(cipherInfo.cipherSuiteName); + mKeyLength = cipherInfo.effectiveKeyBits; + mMacLength = cipherInfo.macBits; + + // Notify consumer code that handshake is complete + nsCOMPtr<nsITLSServerSecurityObserver> observer; + { + MutexAutoLock lock(mLock); + mTlsVersionUsed = channelInfo.protocolVersion; + if (!mSecurityObserver) { + return NS_OK; + } + mSecurityObserver.swap(observer); + } + nsCOMPtr<nsITLSServerSocket> serverSocket; + GetServerSocket(getter_AddRefs(serverSocket)); + observer->OnHandshakeDone(serverSocket, this); + + return NS_OK; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/TLSServerSocket.h b/netwerk/base/TLSServerSocket.h new file mode 100644 index 0000000000..5baba8ee4a --- /dev/null +++ b/netwerk/base/TLSServerSocket.h @@ -0,0 +1,77 @@ +/* vim:set ts=2 sw=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/. */ + +#ifndef mozilla_net_TLSServerSocket_h +#define mozilla_net_TLSServerSocket_h + +#include "nsITLSServerSocket.h" +#include "nsServerSocket.h" +#include "nsString.h" +#include "mozilla/Mutex.h" +#include "seccomon.h" + +namespace mozilla { +namespace net { + +class TLSServerSocket final : public nsServerSocket, public nsITLSServerSocket { + public: + NS_DECL_ISUPPORTS_INHERITED + NS_FORWARD_NSISERVERSOCKET(nsServerSocket::) + NS_DECL_NSITLSSERVERSOCKET + + // Override methods from nsServerSocket + virtual void CreateClientTransport(PRFileDesc* clientFD, + const NetAddr& clientAddr) override; + virtual nsresult SetSocketDefaults() override; + virtual nsresult OnSocketListen() override; + + TLSServerSocket(); + + private: + virtual ~TLSServerSocket() = default; + + static SECStatus AuthCertificateHook(void* arg, PRFileDesc* fd, + PRBool checksig, PRBool isServer); + + nsCOMPtr<nsIX509Cert> mServerCert; +}; + +class TLSServerConnectionInfo : public nsITLSServerConnectionInfo, + public nsITLSClientStatus { + friend class TLSServerSocket; + + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSITLSSERVERCONNECTIONINFO + NS_DECL_NSITLSCLIENTSTATUS + + TLSServerConnectionInfo(); + + private: + virtual ~TLSServerConnectionInfo(); + + static void HandshakeCallback(PRFileDesc* aFD, void* aArg); + nsresult HandshakeCallback(PRFileDesc* aFD); + + RefPtr<TLSServerSocket> mServerSocket; + // Weak ref to the transport, to avoid cycles since the transport holds a + // reference to the TLSServerConnectionInfo object. This is not handed out to + // anyone, and is only used in HandshakeCallback to close the transport in + // case of an error. After this, it's set to nullptr. + nsISocketTransport* mTransport; + nsCOMPtr<nsIX509Cert> mPeerCert; + int16_t mTlsVersionUsed; + nsCString mCipherName; + uint32_t mKeyLength; + uint32_t mMacLength; + // lock protects access to mSecurityObserver + mozilla::Mutex mLock; + nsCOMPtr<nsITLSServerSecurityObserver> mSecurityObserver; +}; + +} // namespace net +} // namespace mozilla + +#endif // mozilla_net_TLSServerSocket_h diff --git a/netwerk/base/TRRLoadInfo.cpp b/netwerk/base/TRRLoadInfo.cpp new file mode 100644 index 0000000000..970a873bc5 --- /dev/null +++ b/netwerk/base/TRRLoadInfo.cpp @@ -0,0 +1,682 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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 "TRRLoadInfo.h" +#include "mozilla/dom/ClientSource.h" +#include "nsContentUtils.h" +#include "nsIRedirectHistoryEntry.h" + +using namespace mozilla::dom; + +namespace mozilla { +namespace net { + +NS_IMPL_ISUPPORTS(TRRLoadInfo, nsILoadInfo) + +TRRLoadInfo::TRRLoadInfo(nsIURI* aResultPrincipalURI, + nsContentPolicyType aContentPolicyType) + : mResultPrincipalURI(aResultPrincipalURI), + mInternalContentPolicyType(aContentPolicyType) {} + +already_AddRefed<nsILoadInfo> TRRLoadInfo::Clone() const { + nsCOMPtr<nsILoadInfo> loadInfo = + new TRRLoadInfo(mResultPrincipalURI, mInternalContentPolicyType); + + return loadInfo.forget(); +} + +NS_IMETHODIMP +TRRLoadInfo::GetLoadingPrincipal(nsIPrincipal** aLoadingPrincipal) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +nsIPrincipal* TRRLoadInfo::VirtualGetLoadingPrincipal() { return nullptr; } + +NS_IMETHODIMP +TRRLoadInfo::GetTriggeringPrincipal(nsIPrincipal** aTriggeringPrincipal) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +nsIPrincipal* TRRLoadInfo::TriggeringPrincipal() { return nullptr; } + +NS_IMETHODIMP +TRRLoadInfo::GetPrincipalToInherit(nsIPrincipal** aPrincipalToInherit) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetPrincipalToInherit(nsIPrincipal* aPrincipalToInherit) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +nsIPrincipal* TRRLoadInfo::PrincipalToInherit() { return nullptr; } + +nsIPrincipal* TRRLoadInfo::FindPrincipalToInherit(nsIChannel* aChannel) { + return nullptr; +} + +nsIPrincipal* TRRLoadInfo::GetSandboxedLoadingPrincipal() { return nullptr; } + +nsIPrincipal* TRRLoadInfo::GetTopLevelPrincipal() { return nullptr; } + +nsIPrincipal* TRRLoadInfo::GetTopLevelStorageAreaPrincipal() { return nullptr; } + +NS_IMETHODIMP +TRRLoadInfo::GetLoadingDocument(Document** aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +nsINode* TRRLoadInfo::LoadingNode() { return nullptr; } + +already_AddRefed<nsISupports> TRRLoadInfo::ContextForTopLevelLoad() { + return nullptr; +} + +already_AddRefed<nsISupports> TRRLoadInfo::GetLoadingContext() { + return nullptr; +} + +NS_IMETHODIMP +TRRLoadInfo::GetLoadingContextXPCOM(nsISupports** aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetSecurityFlags(nsSecurityFlags* aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetSandboxFlags(uint32_t* aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} +NS_IMETHODIMP +TRRLoadInfo::GetTriggeringSandboxFlags(uint32_t* aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} +NS_IMETHODIMP +TRRLoadInfo::SetTriggeringSandboxFlags(uint32_t aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetSecurityMode(uint32_t* aFlags) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetIsInThirdPartyContext(bool* aIsInThirdPartyContext) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetIsInThirdPartyContext(bool aIsInThirdPartyContext) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetIsThirdPartyContextToTopWindow( + bool* aIsThirdPartyContextToTopWindow) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetIsThirdPartyContextToTopWindow( + bool aIsThirdPartyContextToTopWindow) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetCookiePolicy(uint32_t* aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetCookieJarSettings(nsICookieJarSettings** aCookieJarSettings) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetCookieJarSettings(nsICookieJarSettings* aCookieJarSettings) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetHasStoragePermission(bool* aHasStoragePermission) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetHasStoragePermission(bool aHasStoragePermission) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetForceInheritPrincipal(bool* aInheritPrincipal) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetForceInheritPrincipalOverruleOwner(bool* aInheritPrincipal) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetLoadingSandboxed(bool* aLoadingSandboxed) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetAboutBlankInherits(bool* aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetAllowChrome(bool* aResult) { return NS_ERROR_NOT_IMPLEMENTED; } + +NS_IMETHODIMP +TRRLoadInfo::GetDisallowScript(bool* aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetDontFollowRedirects(bool* aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetLoadErrorPage(bool* aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetIsFormSubmission(bool* aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetIsFormSubmission(bool aValue) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetSendCSPViolationEvents(bool* aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetSendCSPViolationEvents(bool aValue) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetExternalContentPolicyType(nsContentPolicyType* aResult) { + // We have to use nsContentPolicyType because ExtContentPolicyType is not + // visible from xpidl. + *aResult = static_cast<nsContentPolicyType>( + nsContentUtils::InternalContentPolicyTypeToExternal( + mInternalContentPolicyType)); + return NS_OK; +} + +nsContentPolicyType TRRLoadInfo::InternalContentPolicyType() { + return mInternalContentPolicyType; +} + +NS_IMETHODIMP +TRRLoadInfo::GetBlockAllMixedContent(bool* aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetUpgradeInsecureRequests(bool* aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetBrowserUpgradeInsecureRequests(bool* aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetBrowserDidUpgradeInsecureRequests(bool* aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetBrowserDidUpgradeInsecureRequests( + bool aBrowserDidUpgradeInsecureRequests) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetBrowserWouldUpgradeInsecureRequests(bool* aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetForceAllowDataURI(bool aForceAllowDataURI) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetForceAllowDataURI(bool* aForceAllowDataURI) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetAllowInsecureRedirectToDataURI( + bool aAllowInsecureRedirectToDataURI) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetAllowInsecureRedirectToDataURI( + bool* aAllowInsecureRedirectToDataURI) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetBypassCORSChecks(bool aBypassCORSChecks) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetBypassCORSChecks(bool* aBypassCORSChecks) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetSkipContentPolicyCheckForWebRequest(bool aSkip) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetSkipContentPolicyCheckForWebRequest(bool* aSkip) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetOriginalFrameSrcLoad(bool aOriginalFrameSrcLoad) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetOriginalFrameSrcLoad(bool* aOriginalFrameSrcLoad) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetForceInheritPrincipalDropped(bool* aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetInnerWindowID(uint64_t* aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetBrowsingContextID(uint64_t* aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetFrameBrowsingContextID(uint64_t* aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetTargetBrowsingContextID(uint64_t* aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetBrowsingContext(dom::BrowsingContext** aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetFrameBrowsingContext(dom::BrowsingContext** aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetTargetBrowsingContext(dom::BrowsingContext** aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetScriptableOriginAttributes( + JSContext* aCx, JS::MutableHandle<JS::Value> aOriginAttributes) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::ResetPrincipalToInheritToNullPrincipal() { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetScriptableOriginAttributes( + JSContext* aCx, JS::Handle<JS::Value> aOriginAttributes) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +nsresult TRRLoadInfo::GetOriginAttributes( + mozilla::OriginAttributes* aOriginAttributes) { + NS_ENSURE_ARG(aOriginAttributes); + *aOriginAttributes = mOriginAttributes; + return NS_OK; +} + +nsresult TRRLoadInfo::SetOriginAttributes( + const mozilla::OriginAttributes& aOriginAttributes) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetInitialSecurityCheckDone(bool aInitialSecurityCheckDone) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetInitialSecurityCheckDone(bool* aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::AppendRedirectHistoryEntry(nsIRedirectHistoryEntry* aEntry, + bool aIsInternalRedirect) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetRedirectChainIncludingInternalRedirects( + JSContext* aCx, JS::MutableHandle<JS::Value> aChain) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +const nsTArray<nsCOMPtr<nsIRedirectHistoryEntry>>& +TRRLoadInfo::RedirectChainIncludingInternalRedirects() { + return mEmptyRedirectChain; +} + +NS_IMETHODIMP +TRRLoadInfo::GetRedirectChain(JSContext* aCx, + JS::MutableHandle<JS::Value> aChain) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +const nsTArray<nsCOMPtr<nsIRedirectHistoryEntry>>& +TRRLoadInfo::RedirectChain() { + return mEmptyRedirectChain; +} + +const nsTArray<nsCOMPtr<nsIPrincipal>>& TRRLoadInfo::AncestorPrincipals() { + return mEmptyPrincipals; +} + +const nsTArray<uint64_t>& TRRLoadInfo::AncestorBrowsingContextIDs() { + return mEmptyBrowsingContextIDs; +} + +void TRRLoadInfo::SetCorsPreflightInfo(const nsTArray<nsCString>& aHeaders, + bool aForcePreflight) {} + +const nsTArray<nsCString>& TRRLoadInfo::CorsUnsafeHeaders() { + return mCorsUnsafeHeaders; +} + +NS_IMETHODIMP +TRRLoadInfo::GetForcePreflight(bool* aForcePreflight) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetIsPreflight(bool* aIsPreflight) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetLoadTriggeredFromExternal(bool aLoadTriggeredFromExternal) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetLoadTriggeredFromExternal(bool* aLoadTriggeredFromExternal) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetServiceWorkerTaintingSynthesized( + bool* aServiceWorkerTaintingSynthesized) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetTainting(uint32_t* aTaintingOut) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::MaybeIncreaseTainting(uint32_t aTainting) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +void TRRLoadInfo::SynthesizeServiceWorkerTainting(LoadTainting aTainting) {} + +NS_IMETHODIMP +TRRLoadInfo::GetDocumentHasUserInteracted(bool* aDocumentHasUserInteracted) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetDocumentHasUserInteracted(bool aDocumentHasUserInteracted) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetAllowListFutureDocumentsCreatedFromThisRedirectChain( + bool* aValue) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetAllowListFutureDocumentsCreatedFromThisRedirectChain( + bool aValue) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetCspNonce(nsAString& aCspNonce) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetCspNonce(const nsAString& aCspNonce) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetSkipContentSniffing(bool* aSkipContentSniffing) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetSkipContentSniffing(bool aSkipContentSniffing) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetIsTopLevelLoad(bool* aResult) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetIsFromProcessingFrameAttributes( + bool* aIsFromProcessingFrameAttributes) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetResultPrincipalURI(nsIURI** aURI) { + nsCOMPtr<nsIURI> uri = mResultPrincipalURI; + uri.forget(aURI); + return NS_OK; +} + +NS_IMETHODIMP +TRRLoadInfo::SetResultPrincipalURI(nsIURI* aURI) { + mResultPrincipalURI = aURI; + return NS_OK; +} + +NS_IMETHODIMP +TRRLoadInfo::SetRequestBlockingReason(uint32_t aReason) { + return NS_ERROR_NOT_IMPLEMENTED; +} +NS_IMETHODIMP +TRRLoadInfo::GetRequestBlockingReason(uint32_t* aReason) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +void TRRLoadInfo::SetClientInfo(const ClientInfo& aClientInfo) {} + +const Maybe<ClientInfo>& TRRLoadInfo::GetClientInfo() { return mClientInfo; } + +void TRRLoadInfo::GiveReservedClientSource( + UniquePtr<ClientSource>&& aClientSource) {} + +UniquePtr<ClientSource> TRRLoadInfo::TakeReservedClientSource() { + return nullptr; +} + +void TRRLoadInfo::SetReservedClientInfo(const ClientInfo& aClientInfo) {} + +void TRRLoadInfo::OverrideReservedClientInfoInParent( + const ClientInfo& aClientInfo) {} + +const Maybe<ClientInfo>& TRRLoadInfo::GetReservedClientInfo() { + return mReservedClientInfo; +} + +void TRRLoadInfo::SetInitialClientInfo(const ClientInfo& aClientInfo) {} + +const Maybe<ClientInfo>& TRRLoadInfo::GetInitialClientInfo() { + return mInitialClientInfo; +} + +void TRRLoadInfo::SetController(const ServiceWorkerDescriptor& aServiceWorker) { +} + +void TRRLoadInfo::ClearController() {} + +const Maybe<ServiceWorkerDescriptor>& TRRLoadInfo::GetController() { + return mController; +} + +void TRRLoadInfo::SetPerformanceStorage( + PerformanceStorage* aPerformanceStorage) {} + +PerformanceStorage* TRRLoadInfo::GetPerformanceStorage() { return nullptr; } + +NS_IMETHODIMP +TRRLoadInfo::GetCspEventListener(nsICSPEventListener** aCSPEventListener) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetCspEventListener(nsICSPEventListener* aCSPEventListener) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +already_AddRefed<nsIContentSecurityPolicy> TRRLoadInfo::GetCsp() { + return nullptr; +} + +already_AddRefed<nsIContentSecurityPolicy> TRRLoadInfo::GetPreloadCsp() { + return nullptr; +} + +already_AddRefed<nsIContentSecurityPolicy> TRRLoadInfo::GetCspToInherit() { + return nullptr; +} + +NS_IMETHODIMP +TRRLoadInfo::GetHttpsOnlyStatus(uint32_t* aHttpsOnlyStatus) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetHttpsOnlyStatus(uint32_t aHttpsOnlyStatus) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetHasValidUserGestureActivation( + bool* aHasValidUserGestureActivation) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetHasValidUserGestureActivation( + bool aHasValidUserGestureActivation) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetInternalContentPolicyType(nsContentPolicyType* aResult) { + *aResult = mInternalContentPolicyType; + return NS_OK; +} + +NS_IMETHODIMP +TRRLoadInfo::GetAllowDeprecatedSystemRequests( + bool* aAllowDeprecatedSystemRequests) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetAllowDeprecatedSystemRequests( + bool aAllowDeprecatedSystemRequests) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetIsInDevToolsContext(bool* aIsInDevToolsContext) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetIsInDevToolsContext(bool aIsInDevToolsContext) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetParserCreatedScript(bool* aParserCreatedScript) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetParserCreatedScript(bool aParserCreatedScript) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::GetLoadingEmbedderPolicy( + nsILoadInfo::CrossOriginEmbedderPolicy* aOutPolicy) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +TRRLoadInfo::SetLoadingEmbedderPolicy( + nsILoadInfo::CrossOriginEmbedderPolicy aPolicy) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/TRRLoadInfo.h b/netwerk/base/TRRLoadInfo.h new file mode 100644 index 0000000000..bd18dc7562 --- /dev/null +++ b/netwerk/base/TRRLoadInfo.h @@ -0,0 +1,52 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +#ifndef mozilla_TRRLoadInfo_h +#define mozilla_TRRLoadInfo_h + +#include "nsILoadInfo.h" +#include "nsIURI.h" +#include "nsTArray.h" +#include "mozilla/dom/ClientInfo.h" +#include "mozilla/dom/ServiceWorkerDescriptor.h" +#include "mozilla/OriginAttributes.h" + +namespace mozilla { +namespace net { + +// TRRLoadInfo is designed to be used by TRRServiceChannel only. Most of +// nsILoadInfo functions are not implemented since TRRLoadInfo needs to +// support off main thread. +class TRRLoadInfo final : public nsILoadInfo { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSILOADINFO + + TRRLoadInfo(nsIURI* aResultPrincipalURI, + nsContentPolicyType aContentPolicyType); + + already_AddRefed<nsILoadInfo> Clone() const; + + private: + virtual ~TRRLoadInfo() = default; + + nsCOMPtr<nsIURI> mResultPrincipalURI; + nsContentPolicyType mInternalContentPolicyType; + OriginAttributes mOriginAttributes; + nsTArray<nsCOMPtr<nsIRedirectHistoryEntry>> mEmptyRedirectChain; + nsTArray<nsCOMPtr<nsIPrincipal>> mEmptyPrincipals; + nsTArray<uint64_t> mEmptyBrowsingContextIDs; + nsTArray<nsCString> mCorsUnsafeHeaders; + Maybe<mozilla::dom::ClientInfo> mClientInfo; + Maybe<mozilla::dom::ClientInfo> mReservedClientInfo; + Maybe<mozilla::dom::ClientInfo> mInitialClientInfo; + Maybe<mozilla::dom::ServiceWorkerDescriptor> mController; +}; + +} // namespace net +} // namespace mozilla + +#endif // mozilla_TRRLoadInfo_h diff --git a/netwerk/base/ThrottleQueue.cpp b/netwerk/base/ThrottleQueue.cpp new file mode 100644 index 0000000000..535ed8d169 --- /dev/null +++ b/netwerk/base/ThrottleQueue.cpp @@ -0,0 +1,399 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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 "ThrottleQueue.h" +#include "mozilla/net/InputChannelThrottleQueueParent.h" +#include "nsISeekableStream.h" +#include "nsIAsyncInputStream.h" +#include "nsIOService.h" +#include "nsStreamUtils.h" +#include "nsNetUtil.h" + +namespace mozilla { +namespace net { + +//----------------------------------------------------------------------------- + +class ThrottleInputStream final : public nsIAsyncInputStream, + public nsISeekableStream { + public: + ThrottleInputStream(nsIInputStream* aStream, ThrottleQueue* aQueue); + + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIINPUTSTREAM + NS_DECL_NSISEEKABLESTREAM + NS_DECL_NSITELLABLESTREAM + NS_DECL_NSIASYNCINPUTSTREAM + + void AllowInput(); + + private: + ~ThrottleInputStream(); + + nsCOMPtr<nsIInputStream> mStream; + RefPtr<ThrottleQueue> mQueue; + nsresult mClosedStatus; + + nsCOMPtr<nsIInputStreamCallback> mCallback; + nsCOMPtr<nsIEventTarget> mEventTarget; +}; + +NS_IMPL_ISUPPORTS(ThrottleInputStream, nsIAsyncInputStream, nsIInputStream, + nsITellableStream, nsISeekableStream) + +ThrottleInputStream::ThrottleInputStream(nsIInputStream* aStream, + ThrottleQueue* aQueue) + : mStream(aStream), mQueue(aQueue), mClosedStatus(NS_OK) { + MOZ_ASSERT(aQueue != nullptr); +} + +ThrottleInputStream::~ThrottleInputStream() { Close(); } + +NS_IMETHODIMP +ThrottleInputStream::Close() { + if (NS_FAILED(mClosedStatus)) { + return mClosedStatus; + } + + if (mQueue) { + mQueue->DequeueStream(this); + mQueue = nullptr; + mClosedStatus = NS_BASE_STREAM_CLOSED; + } + return mStream->Close(); +} + +NS_IMETHODIMP +ThrottleInputStream::Available(uint64_t* aResult) { + if (NS_FAILED(mClosedStatus)) { + return mClosedStatus; + } + + return mStream->Available(aResult); +} + +NS_IMETHODIMP +ThrottleInputStream::Read(char* aBuf, uint32_t aCount, uint32_t* aResult) { + if (NS_FAILED(mClosedStatus)) { + return mClosedStatus; + } + + uint32_t realCount; + nsresult rv = mQueue->Available(aCount, &realCount); + if (NS_FAILED(rv)) { + return rv; + } + + if (realCount == 0) { + return NS_BASE_STREAM_WOULD_BLOCK; + } + + rv = mStream->Read(aBuf, realCount, aResult); + if (NS_SUCCEEDED(rv) && *aResult > 0) { + mQueue->RecordRead(*aResult); + } + return rv; +} + +NS_IMETHODIMP +ThrottleInputStream::ReadSegments(nsWriteSegmentFun aWriter, void* aClosure, + uint32_t aCount, uint32_t* aResult) { + if (NS_FAILED(mClosedStatus)) { + return mClosedStatus; + } + + uint32_t realCount; + nsresult rv = mQueue->Available(aCount, &realCount); + if (NS_FAILED(rv)) { + return rv; + } + + if (realCount == 0) { + return NS_BASE_STREAM_WOULD_BLOCK; + } + + rv = mStream->ReadSegments(aWriter, aClosure, realCount, aResult); + if (NS_SUCCEEDED(rv) && *aResult > 0) { + mQueue->RecordRead(*aResult); + } + return rv; +} + +NS_IMETHODIMP +ThrottleInputStream::IsNonBlocking(bool* aNonBlocking) { + *aNonBlocking = true; + return NS_OK; +} + +NS_IMETHODIMP +ThrottleInputStream::Seek(int32_t aWhence, int64_t aOffset) { + if (NS_FAILED(mClosedStatus)) { + return mClosedStatus; + } + + nsCOMPtr<nsISeekableStream> sstream = do_QueryInterface(mStream); + if (!sstream) { + return NS_ERROR_FAILURE; + } + + return sstream->Seek(aWhence, aOffset); +} + +NS_IMETHODIMP +ThrottleInputStream::Tell(int64_t* aResult) { + if (NS_FAILED(mClosedStatus)) { + return mClosedStatus; + } + + nsCOMPtr<nsITellableStream> sstream = do_QueryInterface(mStream); + if (!sstream) { + return NS_ERROR_FAILURE; + } + + return sstream->Tell(aResult); +} + +NS_IMETHODIMP +ThrottleInputStream::SetEOF() { + if (NS_FAILED(mClosedStatus)) { + return mClosedStatus; + } + + nsCOMPtr<nsISeekableStream> sstream = do_QueryInterface(mStream); + if (!sstream) { + return NS_ERROR_FAILURE; + } + + return sstream->SetEOF(); +} + +NS_IMETHODIMP +ThrottleInputStream::CloseWithStatus(nsresult aStatus) { + if (NS_FAILED(mClosedStatus)) { + // Already closed, ignore. + return NS_OK; + } + if (NS_SUCCEEDED(aStatus)) { + aStatus = NS_BASE_STREAM_CLOSED; + } + + mClosedStatus = Close(); + if (NS_SUCCEEDED(mClosedStatus)) { + mClosedStatus = aStatus; + } + return NS_OK; +} + +NS_IMETHODIMP +ThrottleInputStream::AsyncWait(nsIInputStreamCallback* aCallback, + uint32_t aFlags, uint32_t aRequestedCount, + nsIEventTarget* aEventTarget) { + if (aFlags != 0) { + return NS_ERROR_ILLEGAL_VALUE; + } + + mCallback = aCallback; + mEventTarget = aEventTarget; + if (mCallback) { + mQueue->QueueStream(this); + } else { + mQueue->DequeueStream(this); + } + return NS_OK; +} + +void ThrottleInputStream::AllowInput() { + MOZ_ASSERT(mCallback); + nsCOMPtr<nsIInputStreamCallback> callbackEvent = NS_NewInputStreamReadyEvent( + "ThrottleInputStream::AllowInput", mCallback, mEventTarget); + mCallback = nullptr; + mEventTarget = nullptr; + callbackEvent->OnInputStreamReady(this); +} + +//----------------------------------------------------------------------------- + +// static +already_AddRefed<nsIInputChannelThrottleQueue> ThrottleQueue::Create() { + MOZ_ASSERT(XRE_IsParentProcess()); + + nsCOMPtr<nsIInputChannelThrottleQueue> tq; + if (nsIOService::UseSocketProcess()) { + tq = new InputChannelThrottleQueueParent(); + } else { + tq = new ThrottleQueue(); + } + + return tq.forget(); +} + +NS_IMPL_ISUPPORTS(ThrottleQueue, nsIInputChannelThrottleQueue, nsITimerCallback, + nsINamed) + +ThrottleQueue::ThrottleQueue() + : mMeanBytesPerSecond(0), + mMaxBytesPerSecond(0), + mBytesProcessed(0), + mTimerArmed(false) { + nsresult rv; + nsCOMPtr<nsIEventTarget> sts; + nsCOMPtr<nsIIOService> ioService = do_GetIOService(&rv); + if (NS_SUCCEEDED(rv)) + sts = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv); + if (NS_SUCCEEDED(rv)) mTimer = NS_NewTimer(sts); +} + +ThrottleQueue::~ThrottleQueue() { + if (mTimer && mTimerArmed) { + mTimer->Cancel(); + } + mTimer = nullptr; +} + +NS_IMETHODIMP +ThrottleQueue::RecordRead(uint32_t aBytesRead) { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + ThrottleEntry entry; + entry.mTime = TimeStamp::Now(); + entry.mBytesRead = aBytesRead; + mReadEvents.AppendElement(entry); + mBytesProcessed += aBytesRead; + return NS_OK; +} + +NS_IMETHODIMP +ThrottleQueue::Available(uint32_t aRemaining, uint32_t* aAvailable) { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + TimeStamp now = TimeStamp::Now(); + TimeStamp oneSecondAgo = now - TimeDuration::FromSeconds(1); + size_t i; + + // Remove all stale events. + for (i = 0; i < mReadEvents.Length(); ++i) { + if (mReadEvents[i].mTime >= oneSecondAgo) { + break; + } + } + mReadEvents.RemoveElementsAt(0, i); + + uint32_t totalBytes = 0; + for (i = 0; i < mReadEvents.Length(); ++i) { + totalBytes += mReadEvents[i].mBytesRead; + } + + uint32_t spread = mMaxBytesPerSecond - mMeanBytesPerSecond; + double prob = static_cast<double>(rand()) / RAND_MAX; + uint32_t thisSliceBytes = + mMeanBytesPerSecond - spread + static_cast<uint32_t>(2 * spread * prob); + + if (totalBytes >= thisSliceBytes) { + *aAvailable = 0; + } else { + *aAvailable = thisSliceBytes; + } + return NS_OK; +} + +NS_IMETHODIMP +ThrottleQueue::Init(uint32_t aMeanBytesPerSecond, uint32_t aMaxBytesPerSecond) { + // Can be called on any thread. + if (aMeanBytesPerSecond == 0 || aMaxBytesPerSecond == 0 || + aMaxBytesPerSecond < aMeanBytesPerSecond) { + return NS_ERROR_ILLEGAL_VALUE; + } + + mMeanBytesPerSecond = aMeanBytesPerSecond; + mMaxBytesPerSecond = aMaxBytesPerSecond; + return NS_OK; +} + +NS_IMETHODIMP +ThrottleQueue::BytesProcessed(uint64_t* aResult) { + *aResult = mBytesProcessed; + return NS_OK; +} + +NS_IMETHODIMP +ThrottleQueue::WrapStream(nsIInputStream* aInputStream, + nsIAsyncInputStream** aResult) { + nsCOMPtr<nsIAsyncInputStream> result = + new ThrottleInputStream(aInputStream, this); + result.forget(aResult); + return NS_OK; +} + +NS_IMETHODIMP +ThrottleQueue::Notify(nsITimer* aTimer) { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + // A notified reader may need to push itself back on the queue. + // Swap out the list of readers so that this works properly. + nsTArray<RefPtr<ThrottleInputStream>> events = std::move(mAsyncEvents); + + // Optimistically notify all the waiting readers, and then let them + // requeue if there isn't enough bandwidth. + for (size_t i = 0; i < events.Length(); ++i) { + events[i]->AllowInput(); + } + + mTimerArmed = false; + return NS_OK; +} + +NS_IMETHODIMP +ThrottleQueue::GetName(nsACString& aName) { + aName.AssignLiteral("net::ThrottleQueue"); + return NS_OK; +} + +void ThrottleQueue::QueueStream(ThrottleInputStream* aStream) { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + if (mAsyncEvents.IndexOf(aStream) == mAsyncEvents.NoIndex) { + mAsyncEvents.AppendElement(aStream); + + if (!mTimerArmed) { + uint32_t ms = 1000; + if (mReadEvents.Length() > 0) { + TimeStamp t = mReadEvents[0].mTime + TimeDuration::FromSeconds(1); + TimeStamp now = TimeStamp::Now(); + + if (t > now) { + ms = static_cast<uint32_t>((t - now).ToMilliseconds()); + } else { + ms = 1; + } + } + + if (NS_SUCCEEDED( + mTimer->InitWithCallback(this, ms, nsITimer::TYPE_ONE_SHOT))) { + mTimerArmed = true; + } + } + } +} + +void ThrottleQueue::DequeueStream(ThrottleInputStream* aStream) { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + mAsyncEvents.RemoveElement(aStream); +} + +NS_IMETHODIMP +ThrottleQueue::GetMeanBytesPerSecond(uint32_t* aMeanBytesPerSecond) { + NS_ENSURE_ARG(aMeanBytesPerSecond); + + *aMeanBytesPerSecond = mMeanBytesPerSecond; + return NS_OK; +} + +NS_IMETHODIMP +ThrottleQueue::GetMaxBytesPerSecond(uint32_t* aMaxBytesPerSecond) { + NS_ENSURE_ARG(aMaxBytesPerSecond); + + *aMaxBytesPerSecond = mMaxBytesPerSecond; + return NS_OK; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/ThrottleQueue.h b/netwerk/base/ThrottleQueue.h new file mode 100644 index 0000000000..49885e8887 --- /dev/null +++ b/netwerk/base/ThrottleQueue.h @@ -0,0 +1,65 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +#ifndef mozilla_net_ThrottleQueue_h +#define mozilla_net_ThrottleQueue_h + +#include "mozilla/TimeStamp.h" +#include "nsINamed.h" +#include "nsIThrottledInputChannel.h" +#include "nsITimer.h" + +namespace mozilla { +namespace net { + +class ThrottleInputStream; + +/** + * An implementation of nsIInputChannelThrottleQueue that can be used + * to throttle uploads. This class is not thread-safe. + * Initialization and calls to WrapStream may be done on any thread; + * but otherwise, after creation, it can only be used on the socket + * thread. It currently throttles with a one second granularity, so + * may be a bit choppy. + */ + +class ThrottleQueue : public nsIInputChannelThrottleQueue, + public nsITimerCallback, + public nsINamed { + public: + static already_AddRefed<nsIInputChannelThrottleQueue> Create(); + + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIINPUTCHANNELTHROTTLEQUEUE + NS_DECL_NSITIMERCALLBACK + NS_DECL_NSINAMED + + void QueueStream(ThrottleInputStream* aStream); + void DequeueStream(ThrottleInputStream* aStream); + + protected: + ThrottleQueue(); + virtual ~ThrottleQueue(); + + struct ThrottleEntry { + TimeStamp mTime; + uint32_t mBytesRead; + }; + + nsTArray<ThrottleEntry> mReadEvents; + uint32_t mMeanBytesPerSecond; + uint32_t mMaxBytesPerSecond; + uint64_t mBytesProcessed; + + nsTArray<RefPtr<ThrottleInputStream>> mAsyncEvents; + nsCOMPtr<nsITimer> mTimer; + bool mTimerArmed; +}; + +} // namespace net +} // namespace mozilla + +#endif // mozilla_net_ThrottleQueue_h diff --git a/netwerk/base/Tickler.cpp b/netwerk/base/Tickler.cpp new file mode 100644 index 0000000000..1983958cc2 --- /dev/null +++ b/netwerk/base/Tickler.cpp @@ -0,0 +1,245 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "Tickler.h" + +#ifdef MOZ_USE_WIFI_TICKLER +# include "nsComponentManagerUtils.h" +# include "nsINamed.h" +# include "nsServiceManagerUtils.h" +# include "nsThreadUtils.h" +# include "prnetdb.h" + +# include "mozilla/java/GeckoAppShellWrappers.h" +# include "mozilla/jni/Utils.h" + +namespace mozilla { +namespace net { + +NS_IMPL_ISUPPORTS(Tickler, nsISupportsWeakReference, Tickler) + +Tickler::Tickler() + : mLock("Tickler::mLock"), + mActive(false), + mCanceled(false), + mEnabled(false), + mDelay(16), + mDuration(TimeDuration::FromMilliseconds(400)), + mFD(nullptr) { + MOZ_ASSERT(NS_IsMainThread()); +} + +Tickler::~Tickler() { + // non main thread uses of the tickler should hold weak + // references to it if they must hold a reference at all + MOZ_ASSERT(NS_IsMainThread()); + + if (mThread) { + mThread->AsyncShutdown(); + mThread = nullptr; + } + + if (mTimer) mTimer->Cancel(); + if (mFD) PR_Close(mFD); +} + +nsresult Tickler::Init() { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!mTimer); + MOZ_ASSERT(!mActive); + MOZ_ASSERT(!mThread); + MOZ_ASSERT(!mFD); + + if (jni::IsAvailable()) { + java::GeckoAppShell::EnableNetworkNotifications(); + } + + mFD = PR_OpenUDPSocket(PR_AF_INET); + if (!mFD) return NS_ERROR_FAILURE; + + // make sure new socket has a ttl of 1 + // failure is not fatal. + PRSocketOptionData opt; + opt.option = PR_SockOpt_IpTimeToLive; + opt.value.ip_ttl = 1; + PR_SetSocketOption(mFD, &opt); + + nsresult rv = NS_NewNamedThread("wifi tickler", getter_AddRefs(mThread)); + if (NS_FAILED(rv)) return rv; + + nsCOMPtr<nsITimer> tmpTimer = NS_NewTimer(mThread); + if (!tmpTimer) return NS_ERROR_OUT_OF_MEMORY; + + mTimer.swap(tmpTimer); + + mAddr.inet.family = PR_AF_INET; + mAddr.inet.port = PR_htons(4886); + mAddr.inet.ip = 0; + + return NS_OK; +} + +void Tickler::Tickle() { + MutexAutoLock lock(mLock); + MOZ_ASSERT(mThread); + mLastTickle = TimeStamp::Now(); + if (!mActive) MaybeStartTickler(); +} + +void Tickler::PostCheckTickler() { + mLock.AssertCurrentThreadOwns(); + mThread->Dispatch(NewRunnableMethod("net::Tickler::CheckTickler", this, + &Tickler::CheckTickler), + NS_DISPATCH_NORMAL); + return; +} + +void Tickler::MaybeStartTicklerUnlocked() { + MutexAutoLock lock(mLock); + MaybeStartTickler(); +} + +void Tickler::MaybeStartTickler() { + mLock.AssertCurrentThreadOwns(); + if (!NS_IsMainThread()) { + NS_DispatchToMainThread( + NewRunnableMethod("net::Tickler::MaybeStartTicklerUnlocked", this, + &Tickler::MaybeStartTicklerUnlocked)); + return; + } + + if (!mPrefs) mPrefs = do_GetService(NS_PREFSERVICE_CONTRACTID); + if (mPrefs) { + int32_t val; + bool boolVal; + + if (NS_SUCCEEDED( + mPrefs->GetBoolPref("network.tickle-wifi.enabled", &boolVal))) + mEnabled = boolVal; + + if (NS_SUCCEEDED( + mPrefs->GetIntPref("network.tickle-wifi.duration", &val))) { + if (val < 1) val = 1; + if (val > 100000) val = 100000; + mDuration = TimeDuration::FromMilliseconds(val); + } + + if (NS_SUCCEEDED(mPrefs->GetIntPref("network.tickle-wifi.delay", &val))) { + if (val < 1) val = 1; + if (val > 1000) val = 1000; + mDelay = static_cast<uint32_t>(val); + } + } + + PostCheckTickler(); +} + +void Tickler::CheckTickler() { + MutexAutoLock lock(mLock); + MOZ_ASSERT(mThread == NS_GetCurrentThread()); + + bool shouldRun = + (!mCanceled) && ((TimeStamp::Now() - mLastTickle) <= mDuration); + + if ((shouldRun && mActive) || (!shouldRun && !mActive)) + return; // no change in state + + if (mActive) + StopTickler(); + else + StartTickler(); +} + +void Tickler::Cancel() { + MutexAutoLock lock(mLock); + MOZ_ASSERT(NS_IsMainThread()); + mCanceled = true; + if (mThread) PostCheckTickler(); +} + +void Tickler::StopTickler() { + mLock.AssertCurrentThreadOwns(); + MOZ_ASSERT(mThread == NS_GetCurrentThread()); + MOZ_ASSERT(mTimer); + MOZ_ASSERT(mActive); + + mTimer->Cancel(); + mActive = false; +} + +class TicklerTimer final : public nsITimerCallback, public nsINamed { + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSITIMERCALLBACK + + explicit TicklerTimer(Tickler* aTickler) { + mTickler = do_GetWeakReference(aTickler); + } + + // nsINamed + NS_IMETHOD GetName(nsACString& aName) override { + aName.AssignLiteral("TicklerTimer"); + return NS_OK; + } + + private: + ~TicklerTimer() {} + + nsWeakPtr mTickler; +}; + +void Tickler::StartTickler() { + mLock.AssertCurrentThreadOwns(); + MOZ_ASSERT(mThread == NS_GetCurrentThread()); + MOZ_ASSERT(!mActive); + MOZ_ASSERT(mTimer); + + if (NS_SUCCEEDED(mTimer->InitWithCallback(new TicklerTimer(this), + mEnabled ? mDelay : 1000, + nsITimer::TYPE_REPEATING_SLACK))) + mActive = true; +} + +// argument should be in network byte order +void Tickler::SetIPV4Address(uint32_t address) { mAddr.inet.ip = address; } + +// argument should be in network byte order +void Tickler::SetIPV4Port(uint16_t port) { mAddr.inet.port = port; } + +NS_IMPL_ISUPPORTS(TicklerTimer, nsITimerCallback, nsINamed) + +NS_IMETHODIMP TicklerTimer::Notify(nsITimer* timer) { + RefPtr<Tickler> tickler = do_QueryReferent(mTickler); + if (!tickler) return NS_ERROR_FAILURE; + MutexAutoLock lock(tickler->mLock); + + if (!tickler->mFD) { + tickler->StopTickler(); + return NS_ERROR_FAILURE; + } + + if (tickler->mCanceled || + ((TimeStamp::Now() - tickler->mLastTickle) > tickler->mDuration)) { + tickler->StopTickler(); + return NS_OK; + } + + if (!tickler->mEnabled) return NS_OK; + + PR_SendTo(tickler->mFD, "", 0, 0, &tickler->mAddr, 0); + return NS_OK; +} + +} // namespace net +} // namespace mozilla + +#else // not defined MOZ_USE_WIFI_TICKLER + +namespace mozilla { +namespace net { +NS_IMPL_ISUPPORTS0(Tickler) +} // namespace net +} // namespace mozilla + +#endif // defined MOZ_USE_WIFI_TICKLER diff --git a/netwerk/base/Tickler.h b/netwerk/base/Tickler.h new file mode 100644 index 0000000000..88553732ac --- /dev/null +++ b/netwerk/base/Tickler.h @@ -0,0 +1,132 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef mozilla_net_Tickler_h +#define mozilla_net_Tickler_h + +// The tickler sends a regular 0 byte UDP heartbeat out to a +// particular address for a short time after it has been touched. This +// is used on some mobile wifi chipsets to mitigate Power Save Polling +// (PSP) Mode when we are anticipating a response packet +// soon. Typically PSP adds 100ms of latency to a read event because +// the packet delivery is not triggered until the 802.11 beacon is +// delivered to the host (100ms is the standard Access Point +// configuration for the beacon interval.) Requesting a frequent +// transmission and getting a CTS frame from the AP at least that +// frequently allows for low latency receives when we have reason to +// expect them (e.g a SYN-ACK). +// +// The tickler is used to allow RTT based phases of web transport to +// complete quickly when on wifi - ARP, DNS, TCP handshake, SSL +// handshake, HTTP headers, and the TCP slow start phase. The +// transaction is given up to 400 miliseconds by default to get +// through those phases before the tickler is disabled. +// +// The tickler only applies to wifi on mobile right now. Hopefully it +// can also be restricted to particular handset models in the future. + +#if defined(ANDROID) && !defined(MOZ_PROXY_BYPASS_PROTECTION) +# define MOZ_USE_WIFI_TICKLER +#endif + +#include "mozilla/Attributes.h" +#include "nsISupports.h" +#include <stdint.h> + +#ifdef MOZ_USE_WIFI_TICKLER +# include "mozilla/Mutex.h" +# include "mozilla/TimeStamp.h" +# include "nsISupports.h" +# include "nsIThread.h" +# include "nsITimer.h" +# include "nsWeakReference.h" +# include "prio.h" + +class nsIPrefBranch; +#endif + +namespace mozilla { +namespace net { + +#ifdef MOZ_USE_WIFI_TICKLER + +// 8f769ed6-207c-4af9-9f7e-9e832da3754e +# define NS_TICKLER_IID \ + { \ + 0x8f769ed6, 0x207c, 0x4af9, { \ + 0x9f, 0x7e, 0x9e, 0x83, 0x2d, 0xa3, 0x75, 0x4e \ + } \ + } + +class Tickler final : public nsSupportsWeakReference { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECLARE_STATIC_IID_ACCESSOR(NS_TICKLER_IID) + + // These methods are main thread only + Tickler(); + void Cancel(); + nsresult Init(); + void SetIPV4Address(uint32_t address); + void SetIPV4Port(uint16_t port); + + // Tickle the tickler to (re-)start the activity. + // May call from any thread + void Tickle(); + + private: + ~Tickler(); + + friend class TicklerTimer; + Mutex mLock; + nsCOMPtr<nsIThread> mThread; + nsCOMPtr<nsITimer> mTimer; + nsCOMPtr<nsIPrefBranch> mPrefs; + + bool mActive; + bool mCanceled; + bool mEnabled; + uint32_t mDelay; + TimeDuration mDuration; + PRFileDesc* mFD; + + TimeStamp mLastTickle; + PRNetAddr mAddr; + + // These functions may be called from any thread + void PostCheckTickler(); + void MaybeStartTickler(); + void MaybeStartTicklerUnlocked(); + + // Tickler thread only + void CheckTickler(); + void StartTickler(); + void StopTickler(); +}; + +NS_DEFINE_STATIC_IID_ACCESSOR(Tickler, NS_TICKLER_IID) + +#else // not defined MOZ_USE_WIFI_TICKLER + +class Tickler final : public nsISupports { + ~Tickler() = default; + + public: + NS_DECL_THREADSAFE_ISUPPORTS + + Tickler() = default; + nsresult Init() { return NS_ERROR_NOT_IMPLEMENTED; } + void Cancel() {} + void SetIPV4Address(uint32_t){}; + void SetIPV4Port(uint16_t) {} + void Tickle() {} +}; + +#endif // defined MOZ_USE_WIFI_TICKLER + +} // namespace net +} // namespace mozilla + +#endif // mozilla_net_Tickler_h diff --git a/netwerk/base/http-sfv/Cargo.toml b/netwerk/base/http-sfv/Cargo.toml new file mode 100644 index 0000000000..2d97e77732 --- /dev/null +++ b/netwerk/base/http-sfv/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "http_sfv" +version = "0.1.0" +authors = ["barabass <yalyna.ts@gmail.com>"] +edition = "2018" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +nserror = { path = "../../../xpcom/rust/nserror" } +nsstring = { path = "../../../xpcom/rust/nsstring" } +sfv = "0.8.0" +xpcom = { path = "../../../xpcom/rust/xpcom" } +thin-vec = { version = "0.2.1", features = ["gecko-ffi"] } diff --git a/netwerk/base/http-sfv/SFVService.cpp b/netwerk/base/http-sfv/SFVService.cpp new file mode 100644 index 0000000000..9759993e7f --- /dev/null +++ b/netwerk/base/http-sfv/SFVService.cpp @@ -0,0 +1,39 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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 "mozilla/ClearOnShutdown.h" +#include "mozilla/StaticPtr.h" +#include "nsCOMPtr.h" +#include "SFVService.h" + +// This anonymous namespace prevents outside C++ code from improperly accessing +// these implementation details. +namespace { +extern "C" { +// Implemented in Rust. +void new_sfv_service(nsISFVService** result); +} + +static mozilla::StaticRefPtr<nsISFVService> sService; +} // namespace + +namespace mozilla::net { + +already_AddRefed<nsISFVService> GetSFVService() { + nsCOMPtr<nsISFVService> service; + + if (sService) { + service = sService; + } else { + new_sfv_service(getter_AddRefs(service)); + sService = service; + mozilla::ClearOnShutdown(&sService); + } + + return service.forget(); +} + +} // namespace mozilla::net diff --git a/netwerk/base/http-sfv/SFVService.h b/netwerk/base/http-sfv/SFVService.h new file mode 100644 index 0000000000..4016951609 --- /dev/null +++ b/netwerk/base/http-sfv/SFVService.h @@ -0,0 +1,14 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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 "nsIStructuredFieldValues.h" +namespace mozilla { +namespace net { + +already_AddRefed<nsISFVService> GetSFVService(); + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/http-sfv/moz.build b/netwerk/base/http-sfv/moz.build new file mode 100644 index 0000000000..ed857c91a8 --- /dev/null +++ b/netwerk/base/http-sfv/moz.build @@ -0,0 +1,17 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +XPIDL_SOURCES += [ + "nsIStructuredFieldValues.idl", +] + +XPIDL_MODULE = "http-sfv" + +EXPORTS.mozilla.net += ["SFVService.h"] + +SOURCES += ["SFVService.cpp"] + +FINAL_LIBRARY = "xul" diff --git a/netwerk/base/http-sfv/nsIStructuredFieldValues.idl b/netwerk/base/http-sfv/nsIStructuredFieldValues.idl new file mode 100644 index 0000000000..5a70948757 --- /dev/null +++ b/netwerk/base/http-sfv/nsIStructuredFieldValues.idl @@ -0,0 +1,290 @@ +/* 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 "nsISupports.idl" + +/** + * Conceptually, there are three types of structured field (header) values: + * + * Item - can be an Integer, Decimal, String, Token, Byte Sequence, or Boolean. + * It can have associated Parameters. + * List - array of zero or more members, each of which can be an Item or an InnerList, + * both of which can be Parameterized. + * Dictionary - ordered map of name-value pairs, where the names are short textual strings + * and the values are Items or arrays of Items (represented with InnerList), + * both of which can be Parameterized. There can be zero or more members, + * and their names are unique in the scope of the Dictionary they occur within. + * + * + * There's also a few primitive types used to construct structured field values: + * - BareItem used as Item's value or as a parameter value in Parameters. + * - Parameters are an ordered map of key-value pairs that are associated with an Item or InnerList. + * The keys are unique within the scope the Parameters they occur within, and the values are BareItem. + * - InnerList is an array of zero or more Items. Can have Parameters. + * - ListEntry represents either Item or InnerList as a member of List or as member-value in Dictionary. + */ + + + +/** + * nsISFVBareItem is a building block for Item header value (nsISFVItem) and Parameters (nsISFVParams). + * It can be of type BOOL, STRING, DECIMAL, INTEGER, TOKEN, BYTE_SEQUENCE. + * Each type is represented by its own interface which is used to create + * a bare item of that type. + */ +[scriptable, builtinclass, uuid(7072853f-215b-4a8a-92e5-9732bccc377b)] +interface nsISFVBareItem : nsISupports { + const long BOOL = 1; + const long STRING = 2; + const long DECIMAL = 3; + const long INTEGER = 4; + const long TOKEN = 5; + const long BYTE_SEQUENCE = 6; + + /** + * Returns value associated with type of bare item. + * Used to identify type of bare item without querying for interface + * (like nsISFVString, etc). + */ + readonly attribute long long type; +}; + +[scriptable, builtinclass, uuid(843eea44-990a-422c-bbf2-2aa4ba9ee4d2)] +interface nsISFVInteger : nsISFVBareItem { + attribute long long value; +}; + +[scriptable, builtinclass, uuid(df6a0787-7caa-4fef-b145-08c1104c2fde)] +interface nsISFVString : nsISFVBareItem { + attribute ACString value; +}; + +[scriptable, builtinclass, uuid(d263c6d7-4123-4c39-a121-ccf874a19012)] +interface nsISFVBool : nsISFVBareItem { + attribute boolean value; +}; + +[scriptable, builtinclass, uuid(1098da8b-b4df-4526-b985-53dbd4160ad2)] +interface nsISFVDecimal : nsISFVBareItem { + attribute double value; +}; + +[scriptable, builtinclass, uuid(8ad33d52-b9b2-4a17-8aa8-991250fc1214)] +interface nsISFVToken : nsISFVBareItem { + attribute ACString value; +}; + +[scriptable, builtinclass, uuid(887eaef0-19fe-42bc-9a42-9ff773aa8fea)] +interface nsISFVByteSeq : nsISFVBareItem { + attribute ACString value; +}; + + +/** + * nsISFVParams represents parameters, key-value pairs of ACString and nsISFVBareItem, + * which parametrize Item type header or InnerList type withing List type header. + */ +[scriptable, builtinclass, uuid(b1a397d7-3333-43e7-993a-fbe8ab90ee96)] +interface nsISFVParams : nsISupports { + /** + * Return value (nsISFVBareItem) stored for key, if it is present + * + * @throws NS_ERROR_UNEXPECTED if the key does not exist in parameters. + */ + nsISFVBareItem get(in ACString key); + + /** + * Insert a new key-value pair. + * If an equivalent key already exists: the key remains and retains in its place in the order, + * its corresponding value is updated with the new value. + * + * @throws NS_ERROR_UNEXPECTED if supplied item does not implement nsISFVBareItem interface. + */ + void set(in ACString key, in nsISFVBareItem item); + + /** + * Remove the key-value pair equivalent to key. + * + * @throws NS_ERROR_UNEXPECTED upon attempt to delete key that does not exist in parameters. + */ + void delete(in ACString key); + + /** + * Returns array of keys. + */ + Array<ACString> keys(); +}; + +/** + * nsISFVParametrizable is implemented for types that + * can be parametrized with nsISFVParams + */ +[scriptable, builtinclass, uuid(6c0399f8-01de-4b25-b339-68e35e8d2e49)] +interface nsISFVParametrizable : nsISupports { + readonly attribute nsISFVParams params; +}; + +/** + * nsISFVItemOrInnerList represents member in nsISFVList + * or member-value in nsISFVDictionary. + * nsISFVItemOrInnerList is implemented for + * nsISFVItem or nsISFVInnerList, both of which are used + * to create nsISFVList and nsISFVDictionary. + */ +[scriptable, builtinclass, uuid(99ac1b56-b5b3-44e7-ad96-db7444aae4b2)] +interface nsISFVItemOrInnerList : nsISFVParametrizable { +}; + +/** + * nsISFVSerialize indicates that object can be serialized into ACString. + */ +[scriptable, builtinclass, uuid(28b9215d-c131-413c-9482-0004a371a5ec)] +interface nsISFVSerialize : nsISupports { + ACString serialize(); +}; + +/** + * nsISFVItem represents Item structured header value. + */ +[scriptable, builtinclass, uuid(abe8826b-6af7-4e54-bd2c-46ab231700ce)] +interface nsISFVItem : nsISFVItemOrInnerList { + readonly attribute nsISFVBareItem value; + ACString serialize(); +}; + +/** + * nsISFVInnerList can be used as a member of nsISFVList + * or a member-value of nsISFVDictionary. + */ +[scriptable, builtinclass, uuid(b2e52be2-8488-41b2-9ee2-3c48d92d095c)] +interface nsISFVInnerList : nsISFVItemOrInnerList { + attribute Array<nsISFVItem> items; +}; + +/** + * nsISFVList represents List structured header value. + */ +[scriptable, builtinclass, uuid(02bb92a6-d1de-449c-b54f-d137f30c613d)] +interface nsISFVList : nsISFVSerialize { + /** + * Returns array of members. + * QueryInterface can be used on a member to get more specific type. + */ + attribute Array<nsISFVItemOrInnerList> members; + + /** + * In case when header value is split across lines, it's possible + * this method parses supplied line and merges it with members of existing object. + */ + void parseMore(in ACString header); +}; + +/** + * nsISFVDictionary represents nsISFVDictionary structured header value. + */ +[scriptable, builtinclass, uuid(6642a7fe-7026-4eba-b730-05e230ee3437)] +interface nsISFVDictionary : nsISFVSerialize { + + /** + * Return value (nsISFVItemOrInnerList) stored for key, if it is present. + * QueryInterface can be used on a value to get more specific type. + * + * @throws NS_ERROR_UNEXPECTED if the key does not exist in parameters. + */ + nsISFVItemOrInnerList get(in ACString key); + + /** + * Insert a new key-value pair. + * If an equivalent key already exists: the key remains and retains in its place in the order, + * its corresponding value is updated with the new value. + * + * @throws NS_ERROR_UNEXPECTED if supplied item does not implement nsISFVItemOrInnerList interface. + */ + void set(in ACString key, in nsISFVItemOrInnerList member_value); + + /** + * Remove the key-value pair equivalent to key. + * + * @throws NS_ERROR_UNEXPECTED upon attempt to delete key that does not exist in parameters. + */ + void delete(in ACString key); + + /** + * Returns array of keys. + */ + Array<ACString> keys(); + + /** + * In case when header value is split across lines, it's possible + * this method parses supplied line and merges it with members of existing object. + */ + void parseMore(in ACString header); +}; + + +/** + * nsISFVService provides a set of functions for working with HTTP header value as an object. + * It exposes functions for creating object from string containing header value, + * as well as individual components for manual structured header object creation. + */ +[scriptable, builtinclass, uuid(049f4be1-2f22-4438-a8da-518552ed390c)] +interface nsISFVService: nsISupports +{ + /** + * Parses provided string into Dictionary header value (nsISFVDictionary). + * + * @throws NS_ERROR_FAILURE if parsing fails. + */ + nsISFVDictionary parseDictionary(in ACString header); + + /** + * Parses provided string into List header value (nsISFVList). + * + * @throws NS_ERROR_FAILURE if parsing fails. + */ + nsISFVList parseList(in ACString header); + + /** + * Parses provided string into Item header value (nsISFVItem). + * + * @throws NS_ERROR_FAILURE if parsing fails. + */ + nsISFVItem parseItem(in ACString header); + + /** + * The following functions create bare item of specific type. + */ + nsISFVInteger newInteger(in long long value); + nsISFVBool newBool(in bool value); + nsISFVDecimal newDecimal(in double value); + nsISFVString newString(in ACString value); + nsISFVByteSeq newByteSequence(in ACString value); + nsISFVToken newToken(in ACString value); + + /** + * Creates nsISFVParams with no parameters. In other words, it's an empty map byt default. + */ + nsISFVParams newParameters(); + + /** + * Creates nsISFVInnerList from nsISFVItem array and nsISFVParams. + */ + nsISFVInnerList newInnerList(in Array<nsISFVItem> items, in nsISFVParams params); + + /** + * Creates nsISFVItem, which represents Item header value, from nsISFVBareItem and associated nsISFVParams. + */ + nsISFVItem newItem(in nsISFVBareItem value, in nsISFVParams params); + + /** + * Creates nsISFVList, which represents List header value, from array of nsISFVItemOrInnerList. + * nsISFVItemOrInnerList represens either Item (nsISFVItem) or Inner List (nsISFVInnerList). + */ + nsISFVList newList(in Array<nsISFVItemOrInnerList> members); + + /** + * Creates nsISFVDictionary representing Dictionary header value. It is empty by default. + */ + nsISFVDictionary newDictionary(); +}; diff --git a/netwerk/base/http-sfv/src/lib.rs b/netwerk/base/http-sfv/src/lib.rs new file mode 100644 index 0000000000..283d0111ec --- /dev/null +++ b/netwerk/base/http-sfv/src/lib.rs @@ -0,0 +1,870 @@ +/* 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/. */ + +use nserror::{nsresult, NS_ERROR_FAILURE, NS_ERROR_NULL_POINTER, NS_ERROR_UNEXPECTED, NS_OK}; +use nsstring::{nsACString, nsCString}; +use sfv::Parser; +use sfv::SerializeValue; +use sfv::{ + BareItem, Decimal, Dictionary, FromPrimitive, InnerList, Item, List, ListEntry, Parameters, + ParseMore, +}; +use std::cell::RefCell; +use std::ops::Deref; +use thin_vec::ThinVec; +use xpcom::interfaces::{ + nsISFVBareItem, nsISFVBool, nsISFVByteSeq, nsISFVDecimal, nsISFVDictionary, nsISFVInnerList, + nsISFVInteger, nsISFVItem, nsISFVItemOrInnerList, nsISFVList, nsISFVParams, nsISFVService, + nsISFVString, nsISFVToken, +}; +use xpcom::{xpcom, xpcom_method, RefPtr, XpCom}; + +#[no_mangle] +pub unsafe extern "C" fn new_sfv_service(result: *mut *const nsISFVService) { + let service: RefPtr<SFVService> = SFVService::new(); + RefPtr::new(service.coerce::<nsISFVService>()).forget(&mut *result); +} + +#[derive(xpcom)] +#[xpimplements(nsISFVService)] +#[refcnt = "atomic"] +struct InitSFVService {} + +impl SFVService { + fn new() -> RefPtr<SFVService> { + SFVService::allocate(InitSFVService {}) + } + + xpcom_method!(parse_dictionary => ParseDictionary(header: *const nsACString) -> *const nsISFVDictionary); + fn parse_dictionary(&self, header: &nsACString) -> Result<RefPtr<nsISFVDictionary>, nsresult> { + let parsed_dict = Parser::parse_dictionary(&header).map_err(|_| NS_ERROR_FAILURE)?; + let sfv_dict = SFVDictionary::new(); + sfv_dict.value.replace(parsed_dict); + Ok(RefPtr::new(sfv_dict.coerce::<nsISFVDictionary>())) + } + + xpcom_method!(parse_list => ParseList(field_value: *const nsACString) -> *const nsISFVList); + fn parse_list(&self, header: &nsACString) -> Result<RefPtr<nsISFVList>, nsresult> { + let parsed_list = Parser::parse_list(&header).map_err(|_| NS_ERROR_FAILURE)?; + + let mut nsi_members = ThinVec::new(); + for item_or_inner_list in parsed_list.iter() { + nsi_members.push(interface_from_list_entry(item_or_inner_list)?) + } + let sfv_list = SFVList::allocate(InitSFVList { + members: RefCell::new(nsi_members), + }); + Ok(RefPtr::new(sfv_list.coerce::<nsISFVList>())) + } + + xpcom_method!(parse_item => ParseItem(header: *const nsACString) -> *const nsISFVItem); + fn parse_item(&self, header: &nsACString) -> Result<RefPtr<nsISFVItem>, nsresult> { + let parsed_item = Parser::parse_item(&header).map_err(|_| NS_ERROR_FAILURE)?; + interface_from_item(&parsed_item) + } + + xpcom_method!(new_integer => NewInteger(value: i64) -> *const nsISFVInteger); + fn new_integer(&self, value: i64) -> Result<RefPtr<nsISFVInteger>, nsresult> { + Ok(RefPtr::new( + SFVInteger::new(value).coerce::<nsISFVInteger>(), + )) + } + + xpcom_method!(new_decimal => NewDecimal(value: f64) -> *const nsISFVDecimal); + fn new_decimal(&self, value: f64) -> Result<RefPtr<nsISFVDecimal>, nsresult> { + Ok(RefPtr::new( + SFVDecimal::new(value).coerce::<nsISFVDecimal>(), + )) + } + + xpcom_method!(new_bool => NewBool(value: bool) -> *const nsISFVBool); + fn new_bool(&self, value: bool) -> Result<RefPtr<nsISFVBool>, nsresult> { + Ok(RefPtr::new(SFVBool::new(value).coerce::<nsISFVBool>())) + } + + xpcom_method!(new_string => NewString(value: *const nsACString) -> *const nsISFVString); + fn new_string(&self, value: &nsACString) -> Result<RefPtr<nsISFVString>, nsresult> { + Ok(RefPtr::new(SFVString::new(value).coerce::<nsISFVString>())) + } + + xpcom_method!(new_token => NewToken(value: *const nsACString) -> *const nsISFVToken); + fn new_token(&self, value: &nsACString) -> Result<RefPtr<nsISFVToken>, nsresult> { + Ok(RefPtr::new(SFVToken::new(value).coerce::<nsISFVToken>())) + } + + xpcom_method!(new_byte_sequence => NewByteSequence(value: *const nsACString) -> *const nsISFVByteSeq); + fn new_byte_sequence(&self, value: &nsACString) -> Result<RefPtr<nsISFVByteSeq>, nsresult> { + Ok(RefPtr::new( + SFVByteSeq::new(value).coerce::<nsISFVByteSeq>(), + )) + } + + xpcom_method!(new_parameters => NewParameters() -> *const nsISFVParams); + fn new_parameters(&self) -> Result<RefPtr<nsISFVParams>, nsresult> { + Ok(RefPtr::new(SFVParams::new().coerce::<nsISFVParams>())) + } + + xpcom_method!(new_item => NewItem(value: *const nsISFVBareItem, params: *const nsISFVParams) -> *const nsISFVItem); + fn new_item( + &self, + value: &nsISFVBareItem, + params: &nsISFVParams, + ) -> Result<RefPtr<nsISFVItem>, nsresult> { + Ok(RefPtr::new( + SFVItem::new(value, params).coerce::<nsISFVItem>(), + )) + } + + xpcom_method!(new_inner_list => NewInnerList(items: *const thin_vec::ThinVec<RefPtr<nsISFVItem>>, params: *const nsISFVParams) -> *const nsISFVInnerList); + fn new_inner_list( + &self, + items: &thin_vec::ThinVec<RefPtr<nsISFVItem>>, + params: &nsISFVParams, + ) -> Result<RefPtr<nsISFVInnerList>, nsresult> { + Ok(RefPtr::new( + SFVInnerList::new(items, params).coerce::<nsISFVInnerList>(), + )) + } + + xpcom_method!(new_list => NewList(members: *const thin_vec::ThinVec<RefPtr<nsISFVItemOrInnerList>>) -> *const nsISFVList); + fn new_list( + &self, + members: &thin_vec::ThinVec<RefPtr<nsISFVItemOrInnerList>>, + ) -> Result<RefPtr<nsISFVList>, nsresult> { + Ok(RefPtr::new(SFVList::new(members).coerce::<nsISFVList>())) + } + + xpcom_method!(new_dictionary => NewDictionary() -> *const nsISFVDictionary); + fn new_dictionary(&self) -> Result<RefPtr<nsISFVDictionary>, nsresult> { + Ok(RefPtr::new( + SFVDictionary::new().coerce::<nsISFVDictionary>(), + )) + } +} + +#[derive(xpcom)] +#[xpimplements(nsISFVInteger, nsISFVBareItem)] +#[refcnt = "nonatomic"] +struct InitSFVInteger { + value: RefCell<i64>, +} + +impl SFVInteger { + fn new(value: i64) -> RefPtr<SFVInteger> { + SFVInteger::allocate(InitSFVInteger { + value: RefCell::new(value), + }) + } + + xpcom_method!(get_value => GetValue() -> i64); + fn get_value(&self) -> Result<i64, nsresult> { + Ok(*self.value.borrow()) + } + + xpcom_method!(set_value => SetValue(value: i64)); + fn set_value(&self, value: i64) -> Result<(), nsresult> { + self.value.replace(value); + Ok(()) + } + + xpcom_method!(get_type => GetType() -> i64); + fn get_type(&self) -> Result<i64, nsresult> { + Ok(nsISFVBareItem::INTEGER) + } + + fn from_bare_item_interface(obj: &nsISFVBareItem) -> &Self { + unsafe { ::std::mem::transmute(obj) } + } +} + +#[derive(xpcom)] +#[xpimplements(nsISFVBool, nsISFVBareItem)] +#[refcnt = "nonatomic"] +struct InitSFVBool { + value: RefCell<bool>, +} + +impl SFVBool { + fn new(value: bool) -> RefPtr<SFVBool> { + SFVBool::allocate(InitSFVBool { + value: RefCell::new(value), + }) + } + + xpcom_method!(get_value => GetValue() -> bool); + fn get_value(&self) -> Result<bool, nsresult> { + Ok(*self.value.borrow()) + } + + xpcom_method!(set_value => SetValue(value: bool)); + fn set_value(&self, value: bool) -> Result<(), nsresult> { + self.value.replace(value); + Ok(()) + } + + xpcom_method!(get_type => GetType() -> i64); + fn get_type(&self) -> Result<i64, nsresult> { + Ok(nsISFVBareItem::BOOL) + } + + fn from_bare_item_interface(obj: &nsISFVBareItem) -> &Self { + unsafe { ::std::mem::transmute(obj) } + } +} + +#[derive(xpcom)] +#[xpimplements(nsISFVString, nsISFVBareItem)] +#[refcnt = "nonatomic"] +struct InitSFVString { + value: RefCell<nsCString>, +} + +impl SFVString { + fn new(value: &nsACString) -> RefPtr<SFVString> { + SFVString::allocate(InitSFVString { + value: RefCell::new(nsCString::from(value)), + }) + } + + xpcom_method!( + get_value => GetValue( + ) -> nsACString + ); + + fn get_value(&self) -> Result<nsCString, nsresult> { + Ok(self.value.borrow().clone()) + } + + xpcom_method!( + set_value => SetValue(value: *const nsACString) + ); + + fn set_value(&self, value: &nsACString) -> Result<(), nsresult> { + self.value.borrow_mut().assign(value); + Ok(()) + } + + xpcom_method!(get_type => GetType() -> i64); + fn get_type(&self) -> Result<i64, nsresult> { + Ok(nsISFVBareItem::STRING) + } + + fn from_bare_item_interface(obj: &nsISFVBareItem) -> &Self { + unsafe { ::std::mem::transmute(obj) } + } +} + +#[derive(xpcom)] +#[xpimplements(nsISFVToken, nsISFVBareItem)] +#[refcnt = "nonatomic"] +struct InitSFVToken { + value: RefCell<nsCString>, +} + +impl SFVToken { + fn new(value: &nsACString) -> RefPtr<SFVToken> { + SFVToken::allocate(InitSFVToken { + value: RefCell::new(nsCString::from(value)), + }) + } + + xpcom_method!( + get_value => GetValue( + ) -> nsACString + ); + + fn get_value(&self) -> Result<nsCString, nsresult> { + Ok(self.value.borrow().clone()) + } + + xpcom_method!( + set_value => SetValue(value: *const nsACString) + ); + + fn set_value(&self, value: &nsACString) -> Result<(), nsresult> { + self.value.borrow_mut().assign(value); + Ok(()) + } + + xpcom_method!(get_type => GetType() -> i64); + fn get_type(&self) -> Result<i64, nsresult> { + Ok(nsISFVBareItem::TOKEN) + } + + fn from_bare_item_interface(obj: &nsISFVBareItem) -> &Self { + unsafe { ::std::mem::transmute(obj) } + } +} + +#[derive(xpcom)] +#[xpimplements(nsISFVByteSeq, nsISFVBareItem)] +#[refcnt = "nonatomic"] +struct InitSFVByteSeq { + value: RefCell<nsCString>, +} + +impl SFVByteSeq { + fn new(value: &nsACString) -> RefPtr<SFVByteSeq> { + SFVByteSeq::allocate(InitSFVByteSeq { + value: RefCell::new(nsCString::from(value)), + }) + } + + xpcom_method!( + get_value => GetValue( + ) -> nsACString + ); + + fn get_value(&self) -> Result<nsCString, nsresult> { + Ok(self.value.borrow().clone()) + } + + xpcom_method!( + set_value => SetValue(value: *const nsACString) + ); + + fn set_value(&self, value: &nsACString) -> Result<(), nsresult> { + self.value.borrow_mut().assign(value); + Ok(()) + } + + xpcom_method!(get_type => GetType() -> i64); + fn get_type(&self) -> Result<i64, nsresult> { + Ok(nsISFVBareItem::BYTE_SEQUENCE) + } + + fn from_bare_item_interface(obj: &nsISFVBareItem) -> &Self { + unsafe { ::std::mem::transmute(obj) } + } +} + +#[derive(xpcom)] +#[xpimplements(nsISFVDecimal, nsISFVBareItem)] +#[refcnt = "nonatomic"] +struct InitSFVDecimal { + value: RefCell<f64>, +} + +impl SFVDecimal { + fn new(value: f64) -> RefPtr<SFVDecimal> { + SFVDecimal::allocate(InitSFVDecimal { + value: RefCell::new(value), + }) + } + + xpcom_method!( + get_value => GetValue( + ) -> f64 + ); + + fn get_value(&self) -> Result<f64, nsresult> { + Ok(*self.value.borrow()) + } + + xpcom_method!( + set_value => SetValue(value: f64) + ); + + fn set_value(&self, value: f64) -> Result<(), nsresult> { + self.value.replace(value); + Ok(()) + } + + xpcom_method!(get_type => GetType() -> i64); + fn get_type(&self) -> Result<i64, nsresult> { + Ok(nsISFVBareItem::DECIMAL) + } + + fn from_bare_item_interface(obj: &nsISFVBareItem) -> &Self { + unsafe { ::std::mem::transmute(obj) } + } +} + +#[derive(xpcom)] +#[xpimplements(nsISFVParams)] +#[refcnt = "nonatomic"] +struct InitSFVParams { + params: RefCell<Parameters>, +} + +impl SFVParams { + fn new() -> RefPtr<SFVParams> { + SFVParams::allocate(InitSFVParams { + params: RefCell::new(Parameters::new()), + }) + } + + xpcom_method!( + get => Get(key: *const nsACString) -> *const nsISFVBareItem + ); + + fn get(&self, key: &nsACString) -> Result<RefPtr<nsISFVBareItem>, nsresult> { + let key = key.to_utf8(); + let params = self.params.borrow(); + let param_val = params.get(key.as_ref()); + + match param_val { + Some(val) => interface_from_bare_item(val), + None => return Err(NS_ERROR_UNEXPECTED), + } + } + + xpcom_method!( + set => Set(key: *const nsACString, item: *const nsISFVBareItem) + ); + + fn set(&self, key: &nsACString, item: &nsISFVBareItem) -> Result<(), nsresult> { + let key = key.to_utf8().into_owned(); + let bare_item = bare_item_from_interface(item)?; + self.params.borrow_mut().insert(key, bare_item); + Ok(()) + } + + xpcom_method!( + delete => Delete(key: *const nsACString) + ); + fn delete(&self, key: &nsACString) -> Result<(), nsresult> { + let key = key.to_utf8(); + let mut params = self.params.borrow_mut(); + + if !params.contains_key(key.as_ref()) { + return Err(NS_ERROR_UNEXPECTED); + } + + // Keeps only entries that don't match key + params.retain(|k, _| k != key.as_ref()); + Ok(()) + } + + xpcom_method!( + keys => Keys() -> thin_vec::ThinVec<nsCString> + ); + fn keys(&self) -> Result<thin_vec::ThinVec<nsCString>, nsresult> { + let keys = self.params.borrow(); + let keys = keys + .keys() + .map(nsCString::from) + .collect::<ThinVec<nsCString>>(); + Ok(keys) + } + + fn from_interface(obj: &nsISFVParams) -> &Self { + unsafe { ::std::mem::transmute(obj) } + } +} + +#[derive(xpcom)] +#[xpimplements(nsISFVItem, nsISFVItemOrInnerList)] +#[refcnt = "nonatomic"] +struct InitSFVItem { + value: RefPtr<nsISFVBareItem>, + params: RefPtr<nsISFVParams>, +} + +impl SFVItem { + fn new(value: &nsISFVBareItem, params: &nsISFVParams) -> RefPtr<SFVItem> { + SFVItem::allocate(InitSFVItem { + value: RefPtr::new(value), + params: RefPtr::new(params), + }) + } + + xpcom_method!( + get_value => GetValue( + ) -> *const nsISFVBareItem + ); + + fn get_value(&self) -> Result<RefPtr<nsISFVBareItem>, nsresult> { + Ok(self.value.clone()) + } + + xpcom_method!( + get_params => GetParams( + ) -> *const nsISFVParams + ); + fn get_params(&self) -> Result<RefPtr<nsISFVParams>, nsresult> { + Ok(self.params.clone()) + } + + xpcom_method!( + serialize => Serialize() -> nsACString + ); + fn serialize(&self) -> Result<nsCString, nsresult> { + let bare_item = bare_item_from_interface(self.value.deref())?; + let params = params_from_interface(self.params.deref())?; + let serialized = Item::with_params(bare_item, params) + .serialize_value() + .map_err(|_| NS_ERROR_FAILURE)?; + Ok(nsCString::from(serialized)) + } + + fn from_interface(obj: &nsISFVItem) -> &Self { + unsafe { ::std::mem::transmute(obj) } + } +} + +#[derive(xpcom)] +#[xpimplements(nsISFVInnerList, nsISFVItemOrInnerList)] +#[refcnt = "nonatomic"] +struct InitSFVInnerList { + items: RefCell<thin_vec::ThinVec<RefPtr<nsISFVItem>>>, + params: RefPtr<nsISFVParams>, +} + +impl SFVInnerList { + fn new( + items: &thin_vec::ThinVec<RefPtr<nsISFVItem>>, + params: &nsISFVParams, + ) -> RefPtr<SFVInnerList> { + SFVInnerList::allocate(InitSFVInnerList { + items: RefCell::new((*items).clone()), + params: RefPtr::new(params), + }) + } + + xpcom_method!( + get_items => GetItems() -> thin_vec::ThinVec<RefPtr<nsISFVItem>> + ); + + fn get_items(&self) -> Result<thin_vec::ThinVec<RefPtr<nsISFVItem>>, nsresult> { + let items = self.items.borrow().clone(); + Ok(items) + } + + #[allow(non_snake_case)] + unsafe fn SetItems(&self, value: *const thin_vec::ThinVec<RefPtr<nsISFVItem>>) -> nsresult { + if value.is_null() { + return NS_ERROR_NULL_POINTER; + } + *self.items.borrow_mut() = (*value).clone(); + NS_OK + } + + xpcom_method!( + get_params => GetParams( + ) -> *const nsISFVParams + ); + fn get_params(&self) -> Result<RefPtr<nsISFVParams>, nsresult> { + Ok(self.params.clone()) + } + + fn from_interface(obj: &nsISFVInnerList) -> &Self { + unsafe { ::std::mem::transmute(obj) } + } +} + +#[derive(xpcom)] +#[xpimplements(nsISFVList, nsISFVSerialize)] +#[refcnt = "nonatomic"] +struct InitSFVList { + members: RefCell<thin_vec::ThinVec<RefPtr<nsISFVItemOrInnerList>>>, +} + +impl SFVList { + fn new(members: &thin_vec::ThinVec<RefPtr<nsISFVItemOrInnerList>>) -> RefPtr<SFVList> { + SFVList::allocate(InitSFVList { + members: RefCell::new((*members).clone()), + }) + } + + xpcom_method!( + get_members => GetMembers() -> thin_vec::ThinVec<RefPtr<nsISFVItemOrInnerList>> + ); + + fn get_members(&self) -> Result<thin_vec::ThinVec<RefPtr<nsISFVItemOrInnerList>>, nsresult> { + Ok(self.members.borrow().clone()) + } + + #[allow(non_snake_case)] + unsafe fn SetMembers( + &self, + value: *const thin_vec::ThinVec<RefPtr<nsISFVItemOrInnerList>>, + ) -> nsresult { + if value.is_null() { + return NS_ERROR_NULL_POINTER; + } + *self.members.borrow_mut() = (*value).clone(); + NS_OK + } + + xpcom_method!( + parse_more => ParseMore(header: *const nsACString) + ); + fn parse_more(&self, header: &nsACString) -> Result<(), nsresult> { + // create List from SFVList to call parse_more on it + let mut list = List::new(); + for interface_entry in self.get_members()?.iter() { + let item_or_inner_list = list_entry_from_interface(interface_entry)?; + list.push(item_or_inner_list); + } + + let _ = list.parse_more(&header).map_err(|_| NS_ERROR_FAILURE)?; + + // replace SFVList's members with new_members + let mut new_members = ThinVec::new(); + for item_or_inner_list in list.iter() { + new_members.push(interface_from_list_entry(item_or_inner_list)?) + } + self.members.replace(new_members); + Ok(()) + } + + xpcom_method!( + serialize => Serialize() -> nsACString + ); + fn serialize(&self) -> Result<nsCString, nsresult> { + let mut list = List::new(); + + for interface_entry in self.get_members()?.iter() { + let item_or_inner_list = list_entry_from_interface(interface_entry)?; + list.push(item_or_inner_list); + } + + let serialized = list.serialize_value().map_err(|_| NS_ERROR_FAILURE)?; + Ok(nsCString::from(serialized)) + } +} + +#[derive(xpcom)] +#[xpimplements(nsISFVDictionary, nsISFVSerialize)] +#[refcnt = "nonatomic"] +struct InitSFVDictionary { + value: RefCell<Dictionary>, +} + +impl SFVDictionary { + fn new() -> RefPtr<SFVDictionary> { + SFVDictionary::allocate(InitSFVDictionary { + value: RefCell::new(Dictionary::new()), + }) + } + + xpcom_method!( + get => Get(key: *const nsACString) -> *const nsISFVItemOrInnerList + ); + + fn get(&self, key: &nsACString) -> Result<RefPtr<nsISFVItemOrInnerList>, nsresult> { + let key = key.to_utf8(); + let value = self.value.borrow(); + let member_value = value.get(key.as_ref()); + + match member_value { + Some(member) => interface_from_list_entry(member), + None => return Err(NS_ERROR_UNEXPECTED), + } + } + + xpcom_method!( + set => Set(key: *const nsACString, item: *const nsISFVItemOrInnerList) + ); + + fn set(&self, key: &nsACString, member_value: &nsISFVItemOrInnerList) -> Result<(), nsresult> { + let key = key.to_utf8().into_owned(); + let value = list_entry_from_interface(member_value)?; + self.value.borrow_mut().insert(key, value); + Ok(()) + } + + xpcom_method!( + delete => Delete(key: *const nsACString) + ); + + fn delete(&self, key: &nsACString) -> Result<(), nsresult> { + let key = key.to_utf8(); + let mut params = self.value.borrow_mut(); + + if !params.contains_key(key.as_ref()) { + return Err(NS_ERROR_UNEXPECTED); + } + + // Keeps only entries that don't match key + params.retain(|k, _| k != key.as_ref()); + Ok(()) + } + + xpcom_method!( + keys => Keys() -> thin_vec::ThinVec<nsCString> + ); + fn keys(&self) -> Result<thin_vec::ThinVec<nsCString>, nsresult> { + let members = self.value.borrow(); + let keys = members + .keys() + .map(nsCString::from) + .collect::<ThinVec<nsCString>>(); + Ok(keys) + } + + xpcom_method!( + parse_more => ParseMore(header: *const nsACString) + ); + fn parse_more(&self, header: &nsACString) -> Result<(), nsresult> { + let _ = self + .value + .borrow_mut() + .parse_more(&header) + .map_err(|_| NS_ERROR_FAILURE)?; + Ok(()) + } + + xpcom_method!( + serialize => Serialize() -> nsACString + ); + fn serialize(&self) -> Result<nsCString, nsresult> { + let serialized = self + .value + .borrow() + .serialize_value() + .map_err(|_| NS_ERROR_FAILURE)?; + Ok(nsCString::from(serialized)) + } +} + +fn bare_item_from_interface(obj: &nsISFVBareItem) -> Result<BareItem, nsresult> { + let obj = obj + .query_interface::<nsISFVBareItem>() + .ok_or(NS_ERROR_UNEXPECTED)?; + let mut obj_type: i64 = -1; + unsafe { + obj.deref().GetType(&mut obj_type); + } + + match obj_type { + nsISFVBareItem::BOOL => { + let item_value = SFVBool::from_bare_item_interface(obj.deref()).get_value()?; + Ok(BareItem::Boolean(item_value)) + } + nsISFVBareItem::STRING => { + let string_itm = SFVString::from_bare_item_interface(obj.deref()).get_value()?; + let item_value = (*string_itm.to_utf8()).to_string(); + Ok(BareItem::String(item_value)) + } + nsISFVBareItem::TOKEN => { + let token_itm = SFVToken::from_bare_item_interface(obj.deref()).get_value()?; + let item_value = (*token_itm.to_utf8()).to_string(); + Ok(BareItem::Token(item_value)) + } + nsISFVBareItem::INTEGER => { + let item_value = SFVInteger::from_bare_item_interface(obj.deref()).get_value()?; + Ok(BareItem::Integer(item_value)) + } + nsISFVBareItem::DECIMAL => { + let item_value = SFVDecimal::from_bare_item_interface(obj.deref()).get_value()?; + let decimal: Decimal = Decimal::from_f64(item_value).ok_or(NS_ERROR_UNEXPECTED)?; + Ok(BareItem::Decimal(decimal)) + } + nsISFVBareItem::BYTE_SEQUENCE => { + let token_itm = SFVByteSeq::from_bare_item_interface(obj.deref()).get_value()?; + let item_value: String = (*token_itm.to_utf8()).to_string(); + Ok(BareItem::ByteSeq(item_value.into_bytes())) + } + _ => return Err(NS_ERROR_UNEXPECTED), + } +} + +fn params_from_interface(obj: &nsISFVParams) -> Result<Parameters, nsresult> { + let params = SFVParams::from_interface(obj).params.borrow(); + Ok(params.clone()) +} + +fn item_from_interface(obj: &nsISFVItem) -> Result<Item, nsresult> { + let sfv_item = SFVItem::from_interface(obj); + let bare_item = bare_item_from_interface(sfv_item.value.deref())?; + let parameters = params_from_interface(sfv_item.params.deref())?; + Ok(Item::with_params(bare_item, parameters)) +} + +fn inner_list_from_interface(obj: &nsISFVInnerList) -> Result<InnerList, nsresult> { + let sfv_inner_list = SFVInnerList::from_interface(obj); + + let mut inner_list_items: Vec<Item> = vec![]; + for item in sfv_inner_list.items.borrow().iter() { + let item = item_from_interface(item)?; + inner_list_items.push(item); + } + let inner_list_params = params_from_interface(sfv_inner_list.params.deref())?; + Ok(InnerList::with_params(inner_list_items, inner_list_params)) +} + +fn list_entry_from_interface(obj: &nsISFVItemOrInnerList) -> Result<ListEntry, nsresult> { + if let Some(nsi_item) = obj.query_interface::<nsISFVItem>() { + let item = item_from_interface(nsi_item.deref())?; + Ok(ListEntry::Item(item)) + } else if let Some(nsi_inner_list) = obj.query_interface::<nsISFVInnerList>() { + let inner_list = inner_list_from_interface(nsi_inner_list.deref())?; + Ok(ListEntry::InnerList(inner_list)) + } else { + return Err(NS_ERROR_UNEXPECTED); + } +} + +fn interface_from_bare_item(bare_item: &BareItem) -> Result<RefPtr<nsISFVBareItem>, nsresult> { + let bare_item = match bare_item { + BareItem::Boolean(val) => RefPtr::new(SFVBool::new(*val).coerce::<nsISFVBareItem>()), + BareItem::String(val) => { + RefPtr::new(SFVString::new(&nsCString::from(val)).coerce::<nsISFVBareItem>()) + } + BareItem::Token(val) => { + RefPtr::new(SFVToken::new(&nsCString::from(val)).coerce::<nsISFVBareItem>()) + } + BareItem::ByteSeq(val) => RefPtr::new( + SFVByteSeq::new(&nsCString::from(String::from_utf8(val.to_vec()).unwrap())) + .coerce::<nsISFVBareItem>(), + ), + BareItem::Decimal(val) => { + let val = val + .to_string() + .parse::<f64>() + .map_err(|_| NS_ERROR_UNEXPECTED)?; + RefPtr::new(SFVDecimal::new(val).coerce::<nsISFVBareItem>()) + } + BareItem::Integer(val) => RefPtr::new(SFVInteger::new(*val).coerce::<nsISFVBareItem>()), + }; + + Ok(bare_item) +} + +fn interface_from_item(item: &Item) -> Result<RefPtr<nsISFVItem>, nsresult> { + let nsi_bare_item = interface_from_bare_item(&item.bare_item)?; + let nsi_params = interface_from_params(&item.params)?; + Ok(RefPtr::new( + SFVItem::new(&nsi_bare_item, &nsi_params).coerce::<nsISFVItem>(), + )) +} + +fn interface_from_params(params: &Parameters) -> Result<RefPtr<nsISFVParams>, nsresult> { + let sfv_params = SFVParams::new(); + for (key, value) in params.iter() { + sfv_params + .params + .borrow_mut() + .insert(key.clone(), value.clone()); + } + Ok(RefPtr::new(sfv_params.coerce::<nsISFVParams>())) +} + +fn interface_from_list_entry( + member: &ListEntry, +) -> Result<RefPtr<nsISFVItemOrInnerList>, nsresult> { + match member { + ListEntry::Item(item) => { + let nsi_bare_item = interface_from_bare_item(&item.bare_item)?; + let nsi_params = interface_from_params(&item.params)?; + Ok(RefPtr::new( + SFVItem::new(&nsi_bare_item, &nsi_params).coerce::<nsISFVItemOrInnerList>(), + )) + } + ListEntry::InnerList(inner_list) => { + let mut nsi_inner_list = ThinVec::new(); + for item in inner_list.items.iter() { + let nsi_item = interface_from_item(item)?; + nsi_inner_list.push(nsi_item); + } + + let nsi_params = interface_from_params(&inner_list.params)?; + Ok(RefPtr::new( + SFVInnerList::new(&nsi_inner_list, &nsi_params).coerce::<nsISFVItemOrInnerList>(), + )) + } + } +} diff --git a/netwerk/base/moz.build b/netwerk/base/moz.build new file mode 100644 index 0000000000..a165bc5d0e --- /dev/null +++ b/netwerk/base/moz.build @@ -0,0 +1,331 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +XPIDL_SOURCES += [ + "mozIThirdPartyUtil.idl", + "nsIApplicationCache.idl", + "nsIApplicationCacheChannel.idl", + "nsIApplicationCacheContainer.idl", + "nsIApplicationCacheService.idl", + "nsIArrayBufferInputStream.idl", + "nsIAsyncStreamCopier.idl", + "nsIAsyncStreamCopier2.idl", + "nsIAsyncVerifyRedirectCallback.idl", + "nsIAuthInformation.idl", + "nsIAuthModule.idl", + "nsIAuthPrompt.idl", + "nsIAuthPrompt2.idl", + "nsIAuthPromptAdapterFactory.idl", + "nsIAuthPromptCallback.idl", + "nsIAuthPromptProvider.idl", + "nsIBackgroundFileSaver.idl", + "nsIBufferedStreams.idl", + "nsIByteRangeRequest.idl", + "nsICacheInfoChannel.idl", + "nsICachingChannel.idl", + "nsICancelable.idl", + "nsICaptivePortalService.idl", + "nsIChannel.idl", + "nsIChannelEventSink.idl", + "nsIChildChannel.idl", + "nsIClassifiedChannel.idl", + "nsIClassOfService.idl", + "nsIContentSniffer.idl", + "nsIDashboard.idl", + "nsIDashboardEventNotifier.idl", + "nsIDeprecationWarner.idl", + "nsIDHCPClient.idl", + "nsIDownloader.idl", + "nsIEncodedChannel.idl", + "nsIExternalProtocolHandler.idl", + "nsIFileStreams.idl", + "nsIFileURL.idl", + "nsIForcePendingChannel.idl", + "nsIFormPOSTActionChannel.idl", + "nsIHttpAuthenticatorCallback.idl", + "nsIHttpPushListener.idl", + "nsIIncrementalDownload.idl", + "nsIIncrementalStreamLoader.idl", + "nsIInputStreamChannel.idl", + "nsIInputStreamPump.idl", + "nsIIOService.idl", + "nsILoadContextInfo.idl", + "nsILoadGroup.idl", + "nsILoadGroupChild.idl", + "nsILoadInfo.idl", + "nsIMIMEInputStream.idl", + "nsIMultiPartChannel.idl", + "nsINestedURI.idl", + "nsINetAddr.idl", + "nsINetUtil.idl", + "nsINetworkConnectivityService.idl", + "nsINetworkInfoService.idl", + "nsINetworkInterceptController.idl", + "nsINetworkLinkService.idl", + "nsINetworkPredictor.idl", + "nsINetworkPredictorVerifier.idl", + "nsINullChannel.idl", + "nsIParentChannel.idl", + "nsIParentRedirectingChannel.idl", + "nsIPermission.idl", + "nsIPermissionManager.idl", + "nsIPrivateBrowsingChannel.idl", + "nsIProgressEventSink.idl", + "nsIPrompt.idl", + "nsIProtocolHandler.idl", + "nsIProtocolProxyCallback.idl", + "nsIProtocolProxyFilter.idl", + "nsIProtocolProxyService.idl", + "nsIProtocolProxyService2.idl", + "nsIProxiedChannel.idl", + "nsIProxiedProtocolHandler.idl", + "nsIProxyInfo.idl", + "nsIRandomGenerator.idl", + "nsIRedirectChannelRegistrar.idl", + "nsIRedirectHistoryEntry.idl", + "nsIRedirectResultListener.idl", + "nsIRequest.idl", + "nsIRequestContext.idl", + "nsIRequestObserver.idl", + "nsIRequestObserverProxy.idl", + "nsIResumableChannel.idl", + "nsISecCheckWrapChannel.idl", + "nsISecureBrowserUI.idl", + "nsISensitiveInfoHiddenURI.idl", + "nsISerializationHelper.idl", + "nsIServerSocket.idl", + "nsISimpleStreamListener.idl", + "nsISocketFilter.idl", + "nsISocketTransport.idl", + "nsISocketTransportService.idl", + "nsISpeculativeConnect.idl", + "nsIStandardURL.idl", + "nsIStreamListener.idl", + "nsIStreamListenerTee.idl", + "nsIStreamLoader.idl", + "nsIStreamTransportService.idl", + "nsISyncStreamListener.idl", + "nsISystemProxySettings.idl", + "nsIThreadRetargetableRequest.idl", + "nsIThreadRetargetableStreamListener.idl", + "nsIThrottledInputChannel.idl", + "nsITimedChannel.idl", + "nsITLSServerSocket.idl", + "nsITraceableChannel.idl", + "nsITransport.idl", + "nsIUDPSocket.idl", + "nsIUploadChannel.idl", + "nsIUploadChannel2.idl", + "nsIURI.idl", + "nsIURIMutator.idl", + "nsIURIWithSpecialOrigin.idl", + "nsIURL.idl", + "nsIURLParser.idl", + "nsPISocketTransportService.idl", +] + +XPIDL_MODULE = "necko" + +EXPORTS += [ + "netCore.h", + "nsASocketHandler.h", + "nsAsyncRedirectVerifyHelper.h", + "nsBaseChannel.h", + "nsFileStreams.h", + "nsInputStreamPump.h", + "nsMIMEInputStream.h", + "nsNetUtil.h", + "nsReadLine.h", + "nsSerializationHelper.h", + "nsSimpleNestedURI.h", + "nsSimpleURI.h", + "nsStandardURL.h", + "nsStreamListenerWrapper.h", + "nsURIHashKey.h", + "nsURLHelper.h", + "nsURLParsers.h", + "SimpleChannel.h", +] + +EXPORTS.mozilla += [ + "LoadContextInfo.h", + "LoadInfo.h", + "LoadTainting.h", + "nsRedirectHistoryEntry.h", +] + +EXPORTS.mozilla.net += [ + "CaptivePortalService.h", + "Dashboard.h", + "DashboardTypes.h", + "DefaultURI.h", + "IOActivityMonitor.h", + "MemoryDownloader.h", + "NetworkConnectivityService.h", + "PartiallySeekableInputStream.h", + "Predictor.h", + "PrivateBrowsingChannel.h", + "RedirectChannelRegistrar.h", + "RequestContextService.h", + "SimpleChannelParent.h", + "SSLTokensCache.h", + "TCPFastOpen.h", + "ThrottleQueue.h", +] + +UNIFIED_SOURCES += [ + "ArrayBufferInputStream.cpp", + "BackgroundFileSaver.cpp", + "CaptivePortalService.cpp", + "Dashboard.cpp", + "DefaultURI.cpp", + "EventTokenBucket.cpp", + "IOActivityMonitor.cpp", + "LoadContextInfo.cpp", + "LoadInfo.cpp", + "MemoryDownloader.cpp", + "NetworkConnectivityService.cpp", + "NetworkDataCountLayer.cpp", + "nsAsyncRedirectVerifyHelper.cpp", + "nsAsyncStreamCopier.cpp", + "nsAuthInformationHolder.cpp", + "nsBase64Encoder.cpp", + "nsBaseChannel.cpp", + "nsBaseContentStream.cpp", + "nsBufferedStreams.cpp", + "nsDirectoryIndexStream.cpp", + "nsDNSPrefetch.cpp", + "nsDownloader.cpp", + "nsFileStreams.cpp", + "nsIncrementalDownload.cpp", + "nsIncrementalStreamLoader.cpp", + "nsInputStreamChannel.cpp", + "nsInputStreamPump.cpp", + "nsIOService.cpp", + "nsIURIMutatorUtils.cpp", + "nsLoadGroup.cpp", + "nsMIMEInputStream.cpp", + "nsNetAddr.cpp", + "nsNetUtil.cpp", + "nsPACMan.cpp", + "nsPreloadedStream.cpp", + "nsProtocolProxyService.cpp", + "nsProxyInfo.cpp", + "nsRedirectHistoryEntry.cpp", + "nsRequestObserverProxy.cpp", + "nsSerializationHelper.cpp", + "nsServerSocket.cpp", + "nsSimpleNestedURI.cpp", + "nsSimpleStreamListener.cpp", + "nsSimpleURI.cpp", + "nsSocketTransport2.cpp", + "nsSocketTransportService2.cpp", + "nsStandardURL.cpp", + "nsStreamListenerTee.cpp", + "nsStreamListenerWrapper.cpp", + "nsStreamLoader.cpp", + "nsStreamTransportService.cpp", + "nsSyncStreamListener.cpp", + "nsTransportUtils.cpp", + "nsUDPSocket.cpp", + "PartiallySeekableInputStream.cpp", + "PollableEvent.cpp", + "Predictor.cpp", + "ProxyAutoConfig.cpp", + "RedirectChannelRegistrar.cpp", + "RequestContextService.cpp", + "SimpleBuffer.cpp", + "SimpleChannel.cpp", + "SimpleChannelParent.cpp", + "SSLTokensCache.cpp", + "TCPFastOpenLayer.cpp", + "ThrottleQueue.cpp", + "Tickler.cpp", + "TLSServerSocket.cpp", + "TRRLoadInfo.cpp", +] + +if CONFIG["FUZZING"]: + SOURCES += [ + "FuzzyLayer.cpp", + "FuzzySecurityInfo.cpp", + ] + +if CONFIG["FUZZING_INTERFACES"] and CONFIG["LIBFUZZER"]: + include("/tools/fuzzing/libfuzzer-flags.mozbuild") + SOURCES += [ + "nsMediaFragmentURIParser.cpp", + "nsURLHelper.cpp", + "nsURLParsers.cpp", + ] + SOURCES["nsMediaFragmentURIParser.cpp"].flags += libfuzzer_flags + SOURCES["nsURLHelper.cpp"].flags += libfuzzer_flags + SOURCES["nsURLParsers.cpp"].flags += libfuzzer_flags +else: + UNIFIED_SOURCES += [ + "nsMediaFragmentURIParser.cpp", + "nsURLHelper.cpp", + "nsURLParsers.cpp", + ] + + +if CONFIG["MOZ_WIDGET_TOOLKIT"] == "windows": + SOURCES += [ + "nsURLHelperWin.cpp", + "ShutdownLayer.cpp", + ] +elif CONFIG["MOZ_WIDGET_TOOLKIT"] == "cocoa": + SOURCES += [ + "nsURLHelperOSX.cpp", + ] +else: + SOURCES += [ + "nsURLHelperUnix.cpp", + ] + +# nsINetworkInfoService support. +if CONFIG["MOZ_WIDGET_TOOLKIT"] == "windows": + SOURCES += [ + "NetworkInfoServiceWindows.cpp", + "nsNetworkInfoService.cpp", + ] +elif CONFIG["MOZ_WIDGET_TOOLKIT"] == "cocoa": + SOURCES += [ + "NetworkInfoServiceCocoa.cpp", + "nsNetworkInfoService.cpp", + ] +elif CONFIG["OS_ARCH"] == "Linux": + SOURCES += [ + "NetworkInfoServiceLinux.cpp", + "nsNetworkInfoService.cpp", + ] + +EXTRA_JS_MODULES += [ + "NetUtil.jsm", +] + +DIRS += ["mozurl", "rust-helper", "http-sfv"] + +include("/ipc/chromium/chromium-config.mozbuild") + +FINAL_LIBRARY = "xul" + +LOCAL_INCLUDES += [ + "/docshell/base", + "/dom/base", + "/netwerk/protocol/http", + "/netwerk/socket", + "/netwerk/url-classifier", + "/security/manager/ssl", +] + +if CONFIG["MOZ_WIDGET_TOOLKIT"] == "cocoa": + LOCAL_INCLUDES += [ + "/xpcom/base", + ] + +if CONFIG["CC_TYPE"] in ("clang", "gcc"): + CXXFLAGS += ["-Wno-error=shadow"] diff --git a/netwerk/base/mozIThirdPartyUtil.idl b/netwerk/base/mozIThirdPartyUtil.idl new file mode 100644 index 0000000000..dccadd7b44 --- /dev/null +++ b/netwerk/base/mozIThirdPartyUtil.idl @@ -0,0 +1,232 @@ +/* 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 "nsISupports.idl" + +interface nsIURI; +interface mozIDOMWindowProxy; +interface nsIChannel; +interface nsIPrincipal; +interface nsILoadInfo; + +%{C++ + +#include "mozilla/EnumSet.h" + +enum class ThirdPartyAnalysis { + IsForeign, + IsThirdPartyTrackingResource, + IsThirdPartySocialTrackingResource, + IsStorageAccessPermissionGranted, +}; + +using ThirdPartyAnalysisResult = mozilla::EnumSet<ThirdPartyAnalysis>; + +typedef bool (*RequireThirdPartyCheck)(nsILoadInfo*); + +%} + +native ThirdPartyAnalysisResult(ThirdPartyAnalysisResult); +native RequireThirdPartyCheck(RequireThirdPartyCheck); + +/** + * Utility functions for determining whether a given URI, channel, or window + * hierarchy is third party with respect to a known URI. + */ +[scriptable, builtinclass, uuid(fd82700e-ffb4-4932-b7d6-08f0b5697dda)] +interface mozIThirdPartyUtil : nsISupports +{ + /** + * isThirdPartyURI + * + * Determine whether two URIs are third party with respect to each other. + * This is determined by computing the base domain for both URIs. If they can + * be determined, and the base domains match, the request is defined as first + * party. If it cannot be determined because one or both URIs do not have a + * base domain (for instance, in the case of IP addresses, host aliases such + * as 'localhost', or a file:// URI), an exact string comparison on host is + * performed. + * + * For example, the URI "http://mail.google.com/" is not third party with + * respect to "http://images.google.com/", but "http://mail.yahoo.com/" and + * "http://192.168.1.1/" are. + * + * @return true if aFirstURI is third party with respect to aSecondURI. + * + * @throws if either URI is null, has a malformed host, or has an empty host + * and is not a file:// URI. + */ + boolean isThirdPartyURI(in nsIURI aFirstURI, in nsIURI aSecondURI); + + /** + * isThirdPartyWindow + * + * Determine whether the given window hierarchy is third party. This is done + * as follows: + * + * 1) Obtain the URI of the principal associated with 'aWindow'. Call this the + * 'bottom URI'. + * 2) If 'aURI' is provided, determine if it is third party with respect to + * the bottom URI. If so, return. + * 3) Find the same-type parent window, if there is one, and its URI. + * Determine whether it is third party with respect to the bottom URI. If + * so, return. + * + * Therefore, each level in the window hierarchy is tested. (This means that + * nested iframes with different base domains, even though the bottommost and + * topmost URIs might be equal, will be considered third party.) + * + * @param aWindow + * The bottommost window in the hierarchy. + * @param aURI + * A URI to test against. If null, the URI of the principal + * associated with 'aWindow' will be used. + * + * For example, if 'aURI' is "http://mail.google.com/", 'aWindow' has a URI + * of "http://google.com/", and its parent is the topmost content window with + * a URI of "http://mozilla.com", the result will be true. + * + * @return true if 'aURI' is third party with respect to any of the URIs + * associated with aWindow and its same-type parents. + * + * @throws if aWindow is null; the same-type parent of any window in the + * hierarchy cannot be determined; or the URI associated with any + * window in the hierarchy is null, has a malformed host, or has an + * empty host and is not a file:// URI. + * + * @see isThirdPartyURI + */ + boolean isThirdPartyWindow(in mozIDOMWindowProxy aWindow, [optional] in nsIURI aURI); + + /** + * isThirdPartyChannel + * + * Determine whether the given channel and its content window hierarchy is + * third party. This is done as follows: + * + * 1) If 'aChannel' is an nsIHttpChannel and has the + * 'forceAllowThirdPartyCookie' property set, then: + * a) If 'aURI' is null, return false. + * b) Otherwise, find the URI of the channel, determine whether it is + * foreign with respect to 'aURI', and return. + * 2) Find the URI of the channel and determine whether it is third party with + * respect to the URI of the channel. If so, return. + * 3) Obtain the bottommost nsIDOMWindow, and its same-type parent if it + * exists, from the channel's notification callbacks. Then: + * a) If the parent is the same as the bottommost window, and the channel + * has the LOAD_DOCUMENT_URI flag set, return false. This represents the + * case where a toplevel load is occurring and the window's URI has not + * yet been updated. (We have already checked that 'aURI' is not foreign + * with respect to the channel URI.) + * b) Otherwise, return the result of isThirdPartyWindow with arguments + * of the channel's bottommost window and the channel URI, respectively. + * + * Therefore, both the channel's URI and each level in the window hierarchy + * associated with the channel is tested. + * + * @param aChannel + * The channel associated with the load. + * @param aURI + * A URI to test against. If null, the URI of the channel will be used. + * + * For example, if 'aURI' is "http://mail.google.com/", 'aChannel' has a URI + * of "http://google.com/", and its parent is the topmost content window with + * a URI of "http://mozilla.com", the result will be true. + * + * @return true if aURI is third party with respect to the channel URI or any + * of the URIs associated with the same-type window hierarchy of the + * channel. + * + * @throws if 'aChannel' is null; the channel has no notification callbacks or + * an associated window; or isThirdPartyWindow throws. + * + * @see isThirdPartyWindow + */ + boolean isThirdPartyChannel(in nsIChannel aChannel, [optional] in nsIURI aURI); + + /** + * getBaseDomain + * + * Get the base domain for aHostURI; e.g. for "www.bbc.co.uk", this would be + * "bbc.co.uk". Only properly-formed URI's are tolerated, though a trailing + * dot may be present. If aHostURI is an IP address, an alias such as + * 'localhost', an eTLD such as 'co.uk', or the empty string, aBaseDomain will + * be the exact host. The result of this function should only be used in exact + * string comparisons, since substring comparisons will not be valid for the + * special cases elided above. + * + * @param aHostURI + * The URI to analyze. + * + * @return the base domain. + */ + AUTF8String getBaseDomain(in nsIURI aHostURI); + + /** + * NOTE: Long term, this method won't be needed once bug 922464 is fixed which + * will make it possible to parse all URI's off the main thread. + * + * getBaseDomainFromSchemeHost + * + * Get the base domain for aScheme and aHost. Otherwise identical to + * getBaseDomain(). + * + * @param aScheme + * The scheme to analyze. + * + * @param aAsciiHost + * The host to analyze. + * + * @return the base domain. + */ + AUTF8String getBaseDomainFromSchemeHost(in AUTF8String aScheme, + in AUTF8String aAsciiHost); + + /** + * getURIFromWindow + * + * Returns the URI associated with the script object principal for the + * window. + */ + nsIURI getURIFromWindow(in mozIDOMWindowProxy aWindow); + + /** + * getPrincipalFromWindow + * + * Returns the script object principal for the window. + */ + nsIPrincipal getPrincipalFromWindow(in mozIDOMWindowProxy aWindow); + + /** + * getTopWindowForChannel + * + * Returns the top-level window associated with the given channel. + */ + [noscript] + mozIDOMWindowProxy getTopWindowForChannel(in nsIChannel aChannel, [optional] in nsIURI aURIBeingLoaded); + + /* + * Performs a full analysis of a channel. + * + * aChannel the input channel + * aNotify whether to send content blocking notifications if access control checks fail + * aURI optional URI to check for (the channel URI will be used instead if not provided) + * aRequireThirdPartyCheck a functor used to determine whether the load info requires third-party checks + */ + [noscript, notxpcom] + ThirdPartyAnalysisResult analyzeChannel(in nsIChannel aChannel, + in boolean aNotify, + [optional] in nsIURI aURI, + [optional] in RequireThirdPartyCheck aRequireThirdPartyCheck, + out uint32_t aRejectedReason); +}; + +%{ C++ +/** + * The mozIThirdPartyUtil implementation is an XPCOM service registered + * under the ContractID: + */ +#define THIRDPARTYUTIL_CONTRACTID "@mozilla.org/thirdpartyutil;1" +%} + diff --git a/netwerk/base/mozurl/.gitignore b/netwerk/base/mozurl/.gitignore new file mode 100644 index 0000000000..4fffb2f89c --- /dev/null +++ b/netwerk/base/mozurl/.gitignore @@ -0,0 +1,2 @@ +/target +/Cargo.lock diff --git a/netwerk/base/mozurl/Cargo.toml b/netwerk/base/mozurl/Cargo.toml new file mode 100644 index 0000000000..1b09595def --- /dev/null +++ b/netwerk/base/mozurl/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "mozurl" +version = "0.0.1" +authors = ["Nika Layzell <nika@thelayzells.com>"] + +[dependencies] +url = "2.0" +nserror = { path = "../../../xpcom/rust/nserror" } +nsstring = { path = "../../../xpcom/rust/nsstring" } +xpcom = { path = "../../../xpcom/rust/xpcom" } +uuid = { version = "0.8", features = ["v4"] } diff --git a/netwerk/base/mozurl/MozURL.cpp b/netwerk/base/mozurl/MozURL.cpp new file mode 100644 index 0000000000..47a679164a --- /dev/null +++ b/netwerk/base/mozurl/MozURL.cpp @@ -0,0 +1,12 @@ +/* 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 "mozilla/StaticPrefs_security.h" + +extern "C" { + +bool Gecko_StrictFileOriginPolicy() { + return mozilla::StaticPrefs::security_fileuri_strict_origin_policy(); +} +} diff --git a/netwerk/base/mozurl/MozURL.h b/netwerk/base/mozurl/MozURL.h new file mode 100644 index 0000000000..e48a0203cf --- /dev/null +++ b/netwerk/base/mozurl/MozURL.h @@ -0,0 +1,231 @@ +/* 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/. */ + +#ifndef mozURL_h__ +#define mozURL_h__ + +#include "mozilla/net/MozURL_ffi.h" +#include "mozilla/RefPtr.h" +#include "mozilla/Result.h" + +namespace mozilla { +namespace net { + +// This class provides a thread-safe, immutable URL parser. +// As long as there is RefPtr to the object, you may use it on any thread. +// The constructor is private. One can instantiate the object by +// calling the Init() method as such: +// +// RefPtr<MozURL> url; +// nsAutoCString href("http://example.com/path?query#ref"); +// nsresult rv = MozURL::Init(getter_AddRefs(url), href); +// if (NS_SUCCEEDED(rv)) { /* use url */ } +// +// When changing the URL is needed, you need to call the Mutate() method. +// This gives you a Mutator object, on which you can perform setter operations. +// Calling Finalize() on the Mutator will result in a new MozURL and a status +// code. If any of the setter operations failed, it will be reflected in the +// status code, and a null MozURL. +// +// Note: In the case of a domain name containing non-ascii characters, +// GetSpec and GetHostname will return the IDNA(punycode) version of the host. +// Also note that for now, MozURL only supports the UTF-8 charset. +// +// Implementor Note: This type is only a holder for methods in C++, and does not +// reflect the actual layout of the type. +class MozURL final { + public: + static nsresult Init(MozURL** aURL, const nsACString& aSpec, + const MozURL* aBaseURL = nullptr) { + return mozurl_new(aURL, &aSpec, aBaseURL); + } + + nsDependentCSubstring Spec() const { return mozurl_spec(this); } + nsDependentCSubstring Scheme() const { return mozurl_scheme(this); } + nsDependentCSubstring Username() const { return mozurl_username(this); } + nsDependentCSubstring Password() const { return mozurl_password(this); } + // Will return the hostname of URL. If the hostname is an IPv6 address, + // it will be enclosed in square brackets, such as `[::1]` + nsDependentCSubstring Host() const { return mozurl_host(this); } + // Will return the port number, if specified, or -1 + int32_t Port() const { return mozurl_port(this); } + int32_t RealPort() const { return mozurl_real_port(this); } + // If the URL's port number is equal to the default port, will only return the + // hostname, otherwise it will return a string of the form `{host}:{port}` + // See: https://url.spec.whatwg.org/#default-port + nsDependentCSubstring HostPort() const { return mozurl_host_port(this); } + nsDependentCSubstring FilePath() const { return mozurl_filepath(this); } + nsDependentCSubstring Path() const { return mozurl_path(this); } + nsDependentCSubstring Query() const { return mozurl_query(this); } + nsDependentCSubstring Ref() const { return mozurl_fragment(this); } + bool HasFragment() const { return mozurl_has_fragment(this); } + nsDependentCSubstring Directory() const { return mozurl_directory(this); } + nsDependentCSubstring PrePath() const { return mozurl_prepath(this); } + nsDependentCSubstring SpecNoRef() const { return mozurl_spec_no_ref(this); } + + // This matches the definition of origins and base domains in nsIPrincipal for + // almost all URIs (some rare file:// URIs don't match and it would be hard to + // fix them). It definitely matches nsIPrincipal for URIs used in quota + // manager and there are checks in quota manager and its clients that prevent + // different definitions (see QuotaManager::IsPrincipalInfoValid). + // See also TestMozURL.cpp which enumerates a huge pile of URIs and checks + // that origin and base domain definitions are in sync. + void Origin(nsACString& aOrigin) const { mozurl_origin(this, &aOrigin); } + nsresult BaseDomain(nsACString& aBaseDomain) const { + return mozurl_base_domain(this, &aBaseDomain); + } + + nsresult GetCommonBase(const MozURL* aOther, MozURL** aCommon) const { + return mozurl_common_base(this, aOther, aCommon); + } + nsresult GetRelative(const MozURL* aOther, nsACString* aRelative) const { + return mozurl_relative(this, aOther, aRelative); + } + + size_t SizeOf() { return mozurl_sizeof(this); } + + class Mutator { + public: + // Calling this method will result in the creation of a new MozURL that + // adopts the mutator's mURL. + // If any of the setters failed with an error code, that error code will be + // returned here. It will also return an error code if Finalize is called + // more than once on the Mutator. + nsresult Finalize(MozURL** aURL) { + nsresult rv = GetStatus(); + if (NS_SUCCEEDED(rv)) { + mURL.forget(aURL); + } else { + *aURL = nullptr; + } + return rv; + } + + // These setter methods will return a reference to `this` so that you may + // chain setter operations as such: + // + // RefPtr<MozURL> url2; + // nsresult rv = url->Mutate().SetHostname("newhost"_ns) + // .SetFilePath("new/file/path"_ns) + // .Finalize(getter_AddRefs(url2)); + // if (NS_SUCCEEDED(rv)) { /* use url2 */ } + Mutator& SetScheme(const nsACString& aScheme) { + if (NS_SUCCEEDED(GetStatus())) { + mStatus = mozurl_set_scheme(mURL, &aScheme); + } + return *this; + } + Mutator& SetUsername(const nsACString& aUser) { + if (NS_SUCCEEDED(GetStatus())) { + mStatus = mozurl_set_username(mURL, &aUser); + } + return *this; + } + Mutator& SetPassword(const nsACString& aPassword) { + if (NS_SUCCEEDED(GetStatus())) { + mStatus = mozurl_set_password(mURL, &aPassword); + } + return *this; + } + Mutator& SetHostname(const nsACString& aHost) { + if (NS_SUCCEEDED(GetStatus())) { + mStatus = mozurl_set_hostname(mURL, &aHost); + } + return *this; + } + Mutator& SetHostPort(const nsACString& aHostPort) { + if (NS_SUCCEEDED(GetStatus())) { + mStatus = mozurl_set_host_port(mURL, &aHostPort); + } + return *this; + } + Mutator& SetFilePath(const nsACString& aPath) { + if (NS_SUCCEEDED(GetStatus())) { + mStatus = mozurl_set_pathname(mURL, &aPath); + } + return *this; + } + Mutator& SetQuery(const nsACString& aQuery) { + if (NS_SUCCEEDED(GetStatus())) { + mStatus = mozurl_set_query(mURL, &aQuery); + } + return *this; + } + Mutator& SetRef(const nsACString& aRef) { + if (NS_SUCCEEDED(GetStatus())) { + mStatus = mozurl_set_fragment(mURL, &aRef); + } + return *this; + } + Mutator& SetPort(int32_t aPort) { + if (NS_SUCCEEDED(GetStatus())) { + mStatus = mozurl_set_port_no(mURL, aPort); + } + return *this; + } + + // This method returns the status code of the setter operations. + // If any of the setters failed, it will return the code of the first error + // that occured. If none of the setters failed, it will return NS_OK. + // This method is useful to avoid doing expensive operations when the result + // would not be used because an error occurred. For example: + // + // RefPtr<MozURL> url2; + // MozURL::Mutator mut = url->Mutate(); + // mut.SetScheme("!@#$"); // this would fail + // if (NS_SUCCEDED(mut.GetStatus())) { + // nsAutoCString host(ExpensiveComputing()); + // rv = mut.SetHostname(host).Finalize(getter_AddRefs(url2)); + // } + // if (NS_SUCCEEDED(rv)) { /* use url2 */ } + nsresult GetStatus() { return mURL ? mStatus : NS_ERROR_NOT_AVAILABLE; } + + static Result<Mutator, nsresult> FromSpec( + const nsACString& aSpec, const MozURL* aBaseURL = nullptr) { + Mutator m = Mutator(aSpec, aBaseURL); + if (m.mURL) { + MOZ_ASSERT(NS_SUCCEEDED(m.mStatus)); + return m; + } + + MOZ_ASSERT(NS_FAILED(m.mStatus)); + return Err(m.mStatus); + } + + private: + explicit Mutator(MozURL* aUrl) : mStatus(NS_OK) { + mozurl_clone(aUrl, getter_AddRefs(mURL)); + } + + // This is only used to create a mutator from a string without cloning it + // so we avoid a pointless copy in FromSpec. It is important that we + // check the value of mURL afterwards. + explicit Mutator(const nsACString& aSpec, + const MozURL* aBaseURL = nullptr) { + mStatus = mozurl_new(getter_AddRefs(mURL), &aSpec, aBaseURL); + } + RefPtr<MozURL> mURL; + nsresult mStatus; + friend class MozURL; + }; + + Mutator Mutate() { return Mutator(this); } + + // AddRef and Release are non-virtual on this type, and always call into rust. + nsrefcnt AddRef() { return mozurl_addref(this); } + nsrefcnt Release() { return mozurl_release(this); } + + private: + // Make it a compile time error for C++ code to ever create, destruct, or copy + // MozURL objects. All of these operations will be performed by rust. + MozURL(); /* never defined */ + ~MozURL(); /* never defined */ + MozURL(const MozURL&) = delete; + MozURL& operator=(const MozURL&) = delete; +}; + +} // namespace net +} // namespace mozilla + +#endif // mozURL_h__ diff --git a/netwerk/base/mozurl/cbindgen.toml b/netwerk/base/mozurl/cbindgen.toml new file mode 100644 index 0000000000..bb5fdbd08f --- /dev/null +++ b/netwerk/base/mozurl/cbindgen.toml @@ -0,0 +1,61 @@ +header = """/* 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/. */ + +/* The MozURL type is implemented in Rust code, and uses extern "C" FFI calls to + * operate on the internal data structure. This file contains C declarations of + * these files. + + * WARNING: DO NOT CALL ANY OF THESE FUNCTIONS. USE |MozURL| INSTEAD! */ + """ +autogen_warning = """/* DO NOT MODIFY THIS MANUALLY! This file was generated using cbindgen. */ + +namespace mozilla { +namespace net { +class MozURL; +} // namespace net +} // namespace mozilla + +extern "C" { + +// FFI-compatible string slice struct used internally by MozURL. +// Coerces to nsDependentCSubstring. +struct MozURLSpecSlice { + char* mData; + uint32_t mLen; + + operator nsDependentCSubstring() { + return nsDependentCSubstring(mData, mLen); + } +}; + +nsresult mozurl_new(mozilla::net::MozURL** aResult, const nsACString* aSpec, + /* optional */ const mozilla::net::MozURL* aBase); + +void mozurl_clone(const mozilla::net::MozURL* aThis, + mozilla::net::MozURL** aResult); + +nsresult mozurl_common_base(const mozilla::net::MozURL* aUrl1, + const mozilla::net::MozURL* aUrl2, + mozilla::net::MozURL** aResult); +} + +""" + +include_guard = "mozilla_net_MozURL_ffi_h" +include_version = true +braces = "SameLine" +line_length = 100 +tab_width = 2 +language = "C++" +namespaces = [] +includes = ["nsError.h", "nsString.h"] + +[export] +exclude = ["Gecko_StrictFileOriginPolicy", "MozURL", "SpecSlice", "mozurl_new", "mozurl_clone", "mozurl_common_base"] +item_types = ["globals", "enums", "structs", "unions", "typedefs", "opaque", "functions", "constants"] + + +[export.rename] +"SpecSlice" = "MozURLSpecSlice" +"MozURL" = "mozilla::net::MozURL" diff --git a/netwerk/base/mozurl/moz.build b/netwerk/base/mozurl/moz.build new file mode 100644 index 0000000000..0a4e522b5a --- /dev/null +++ b/netwerk/base/mozurl/moz.build @@ -0,0 +1,22 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +EXPORTS.mozilla.net += [ + "MozURL.h", +] + +SOURCES += [ + "MozURL.cpp", +] + +FINAL_LIBRARY = "xul" + +if CONFIG["COMPILE_ENVIRONMENT"]: + CbindgenHeader("MozURL_ffi.h", inputs=["/netwerk/base/mozurl"]) + + EXPORTS.mozilla.net += [ + "!MozURL_ffi.h", + ] diff --git a/netwerk/base/mozurl/src/lib.rs b/netwerk/base/mozurl/src/lib.rs new file mode 100644 index 0000000000..92ea5f3ce0 --- /dev/null +++ b/netwerk/base/mozurl/src/lib.rs @@ -0,0 +1,563 @@ +/* -*- Mode: rust; rust-indent-offset: 2 -*- */ +/* 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/. */ + +extern crate url; +use url::quirks; +use url::{ParseOptions, Position, Url}; + +extern crate nsstring; +use nsstring::{nsACString, nsCString}; + +extern crate nserror; +use nserror::*; + +extern crate xpcom; +use xpcom::interfaces::nsrefcnt; +use xpcom::{AtomicRefcnt, RefCounted, RefPtr}; + +extern crate uuid; +use uuid::Uuid; + +use std::fmt::Write; +use std::marker::PhantomData; +use std::mem; +use std::ops; +use std::ptr; +use std::str; + +extern "C" { + fn Gecko_StrictFileOriginPolicy() -> bool; +} + +/// Helper macro. If the expression $e is Ok(t) evaluates to t, otherwise, +/// returns NS_ERROR_MALFORMED_URI. +macro_rules! try_or_malformed { + ($e:expr) => { + match $e { + Ok(v) => v, + Err(_) => return NS_ERROR_MALFORMED_URI, + } + }; +} + +fn parser<'a>() -> ParseOptions<'a> { + Url::options() +} + +fn default_port(scheme: &str) -> Option<u16> { + match scheme { + "ftp" => Some(21), + "gopher" => Some(70), + "http" => Some(80), + "https" => Some(443), + "ws" => Some(80), + "wss" => Some(443), + "rtsp" => Some(443), + "moz-anno" => Some(443), + "android" => Some(443), + _ => None, + } +} + +/// A slice into the backing string. This type is only valid as long as the +/// MozURL which it was pulled from is valid. In C++, this type implicitly +/// converts to a nsDependentCString, and is an implementation detail. +/// +/// This type exists because, unlike &str, this type is safe to return over FFI. +#[repr(C)] +pub struct SpecSlice<'a> { + data: *const u8, + len: u32, + _marker: PhantomData<&'a [u8]>, +} + +impl<'a> From<&'a str> for SpecSlice<'a> { + fn from(s: &'a str) -> SpecSlice<'a> { + assert!(s.len() < u32::max_value() as usize); + SpecSlice { + data: s.as_ptr(), + len: s.len() as u32, + _marker: PhantomData, + } + } +} + +/// The MozURL reference-counted threadsafe URL type. This type intentionally +/// implements no XPCOM interfaces, and all method calls are non-virtual. +#[repr(C)] +pub struct MozURL { + pub url: Url, + refcnt: AtomicRefcnt, +} + +impl MozURL { + pub fn from_url(url: Url) -> RefPtr<MozURL> { + // Actually allocate the URL on the heap. This is the only place we actually + // create a MozURL, other than in clone(). + unsafe { + RefPtr::from_raw(Box::into_raw(Box::new(MozURL { + url: url, + refcnt: AtomicRefcnt::new(), + }))) + .unwrap() + } + } +} + +impl ops::Deref for MozURL { + type Target = Url; + fn deref(&self) -> &Url { + &self.url + } +} +impl ops::DerefMut for MozURL { + fn deref_mut(&mut self) -> &mut Url { + &mut self.url + } +} + +// Memory Management for MozURL +#[no_mangle] +pub unsafe extern "C" fn mozurl_addref(url: &MozURL) -> nsrefcnt { + url.refcnt.inc() +} + +#[no_mangle] +pub unsafe extern "C" fn mozurl_release(url: &MozURL) -> nsrefcnt { + let rc = url.refcnt.dec(); + if rc == 0 { + Box::from_raw(url as *const MozURL as *mut MozURL); + } + rc +} + +// xpcom::RefPtr support +unsafe impl RefCounted for MozURL { + unsafe fn addref(&self) { + mozurl_addref(self); + } + unsafe fn release(&self) { + mozurl_release(self); + } +} + +// Allocate a new MozURL object with a RefCnt of 1, and store a pointer to it +// into url. +#[no_mangle] +pub extern "C" fn mozurl_new( + result: &mut *const MozURL, + spec: &nsACString, + base: Option<&MozURL>, +) -> nsresult { + *result = ptr::null_mut(); + + let spec = try_or_malformed!(str::from_utf8(spec)); + let url = if let Some(base) = base { + try_or_malformed!(base.url.join(spec)) + } else { + try_or_malformed!(parser().parse(spec)) + }; + + MozURL::from_url(url).forget(result); + NS_OK +} + +/// Allocate a new MozURL object which is a clone of the original, and store a +/// pointer to it into newurl. +#[no_mangle] +pub extern "C" fn mozurl_clone(url: &MozURL, newurl: &mut *const MozURL) { + MozURL::from_url(url.url.clone()).forget(newurl); +} + +#[no_mangle] +pub extern "C" fn mozurl_spec(url: &MozURL) -> SpecSlice { + url.as_ref().into() +} + +#[no_mangle] +pub extern "C" fn mozurl_scheme(url: &MozURL) -> SpecSlice { + url.scheme().into() +} + +#[no_mangle] +pub extern "C" fn mozurl_username(url: &MozURL) -> SpecSlice { + if url.cannot_be_a_base() { + "".into() + } else { + url.username().into() + } +} + +#[no_mangle] +pub extern "C" fn mozurl_password(url: &MozURL) -> SpecSlice { + url.password().unwrap_or("").into() +} + +#[no_mangle] +pub extern "C" fn mozurl_host(url: &MozURL) -> SpecSlice { + url.host_str().unwrap_or("").into() +} + +#[no_mangle] +pub extern "C" fn mozurl_port(url: &MozURL) -> i32 { + // NOTE: Gecko uses -1 to represent the default port. + url.port().map(|p| p as i32).unwrap_or(-1) +} + +#[no_mangle] +pub extern "C" fn mozurl_real_port(url: &MozURL) -> i32 { + url.port() + .or_else(|| default_port(url.scheme())) + .map(|p| p as i32) + .unwrap_or(-1) +} + +#[no_mangle] +pub extern "C" fn mozurl_host_port(url: &MozURL) -> SpecSlice { + (&url[Position::BeforeHost..Position::BeforePath]).into() +} + +#[no_mangle] +pub extern "C" fn mozurl_filepath(url: &MozURL) -> SpecSlice { + url.path().into() +} + +#[no_mangle] +pub extern "C" fn mozurl_path(url: &MozURL) -> SpecSlice { + (&url[Position::BeforePath..]).into() +} + +#[no_mangle] +pub extern "C" fn mozurl_query(url: &MozURL) -> SpecSlice { + url.query().unwrap_or("").into() +} + +#[no_mangle] +pub extern "C" fn mozurl_fragment(url: &MozURL) -> SpecSlice { + url.fragment().unwrap_or("").into() +} + +#[no_mangle] +pub extern "C" fn mozurl_spec_no_ref(url: &MozURL) -> SpecSlice { + (&url[..Position::AfterQuery]).into() +} + +#[no_mangle] +pub extern "C" fn mozurl_has_fragment(url: &MozURL) -> bool { + url.fragment().is_some() +} + +#[no_mangle] +pub extern "C" fn mozurl_directory(url: &MozURL) -> SpecSlice { + if let Some(position) = url.path().rfind('/') { + url.path()[..position + 1].into() + } else { + url.path().into() + } +} + +#[no_mangle] +pub extern "C" fn mozurl_prepath(url: &MozURL) -> SpecSlice { + (&url[..Position::BeforePath]).into() +} + +fn get_origin(url: &MozURL) -> Option<String> { + match url.scheme() { + "blob" | "ftp" | "http" | "https" | "ws" | "wss" => { + Some(url.origin().ascii_serialization()) + } + "indexeddb" | "moz-extension" | "resource" => { + let host = url.host_str().unwrap_or(""); + + let port = url.port().or_else(|| default_port(url.scheme())); + + if port == default_port(url.scheme()) { + Some(format!("{}://{}", url.scheme(), host)) + } else { + Some(format!("{}://{}:{}", url.scheme(), host, port.unwrap())) + } + } + "file" => { + if unsafe { Gecko_StrictFileOriginPolicy() } { + Some(url[..Position::AfterPath].to_owned()) + } else { + Some("file://UNIVERSAL_FILE_URI_ORIGIN".to_owned()) + } + } + "about" | "moz-safe-about" => Some(url[..Position::AfterPath].to_owned()), + _ => None, + } +} + +#[no_mangle] +pub extern "C" fn mozurl_origin(url: &MozURL, origin: &mut nsACString) { + let origin_str = if !url.as_ref().starts_with("about:blank") { + get_origin(url) + } else { + None + }; + + let origin_str = origin_str.unwrap_or_else(|| { + // nsIPrincipal stores the uuid, so the same uuid is returned everytime. + // We can't do that for MozURL because it can be used across threads. + // Storing uuid would mutate the object which would cause races between + // threads. + format!("moz-nullprincipal:{{{}}}", Uuid::new_v4()) + }); + + // NOTE: Try to re-use the allocation we got from rust-url, and transfer + // ownership of the buffer to C++. + let mut o = nsCString::from(origin_str); + origin.take_from(&mut o); +} + +fn get_base_domain(url: &MozURL) -> Result<Option<String>, nsresult> { + match url.scheme() { + "ftp" | "http" | "https" | "moz-extension" | "resource" => { + let third_party_util = xpcom::services::get_ThirdPartyUtil().unwrap(); + + let scheme = nsCString::from(url.scheme()); + + let mut host_str = url.host_str().unwrap_or(""); + + if host_str.starts_with('[') && host_str.ends_with(']') { + host_str = &host_str[1..host_str.len() - 1]; + } + + let host = nsCString::from(host_str); + + unsafe { + let mut string = nsCString::new(); + third_party_util + .GetBaseDomainFromSchemeHost(&*scheme, &*host, &mut *string) + .to_result()?; + + // We know that GetBaseDomainFromSchemeHost returns AUTF8String, so just + // use unwrap(). + Ok(Some(String::from_utf8(string.to_vec()).unwrap())) + } + } + "ws" | "wss" => Ok(Some(url.as_ref().to_owned())), + "file" => { + if unsafe { Gecko_StrictFileOriginPolicy() } { + Ok(Some(url.path().to_owned())) + } else { + Ok(Some("UNIVERSAL_FILE_URI_ORIGIN".to_owned())) + } + } + "about" | "moz-safe-about" | "indexeddb" => Ok(Some(url.as_ref().to_owned())), + _ => Ok(None), + } +} + +#[no_mangle] +pub extern "C" fn mozurl_base_domain(url: &MozURL, base_domain: &mut nsACString) -> nsresult { + let base_domain_str = if !url.as_ref().starts_with("about:blank") { + match get_base_domain(url) { + Ok(domain) => domain, + Err(rv) => return rv, + } + } else { + None + }; + + let base_domain_str = base_domain_str.unwrap_or_else(|| { + // See the comment in mozurl_origin about why we return a new uuid for + // "moz-nullprincipals". + format!("{{{}}}", Uuid::new_v4()) + }); + + let mut bd = nsCString::from(base_domain_str); + base_domain.take_from(&mut bd); + + NS_OK +} + +// Helper macro for debug asserting that we're the only reference to MozURL. +macro_rules! debug_assert_mut { + ($e:expr) => { + debug_assert_eq!($e.refcnt.get(), 1, "Cannot mutate an aliased MozURL!"); + }; +} + +#[no_mangle] +pub extern "C" fn mozurl_set_scheme(url: &mut MozURL, scheme: &nsACString) -> nsresult { + debug_assert_mut!(url); + let scheme = try_or_malformed!(str::from_utf8(scheme)); + try_or_malformed!(quirks::set_protocol(url, scheme)); + NS_OK +} + +#[no_mangle] +pub extern "C" fn mozurl_set_username(url: &mut MozURL, username: &nsACString) -> nsresult { + debug_assert_mut!(url); + let username = try_or_malformed!(str::from_utf8(username)); + try_or_malformed!(quirks::set_username(url, username)); + NS_OK +} + +#[no_mangle] +pub extern "C" fn mozurl_set_password(url: &mut MozURL, password: &nsACString) -> nsresult { + debug_assert_mut!(url); + let password = try_or_malformed!(str::from_utf8(password)); + try_or_malformed!(quirks::set_password(url, password)); + NS_OK +} + +#[no_mangle] +pub extern "C" fn mozurl_set_host_port(url: &mut MozURL, hostport: &nsACString) -> nsresult { + debug_assert_mut!(url); + let hostport = try_or_malformed!(str::from_utf8(hostport)); + try_or_malformed!(quirks::set_host(url, hostport)); + NS_OK +} + +#[no_mangle] +pub extern "C" fn mozurl_set_hostname(url: &mut MozURL, host: &nsACString) -> nsresult { + debug_assert_mut!(url); + let host = try_or_malformed!(str::from_utf8(host)); + try_or_malformed!(quirks::set_hostname(url, host)); + NS_OK +} + +#[no_mangle] +pub extern "C" fn mozurl_set_port_no(url: &mut MozURL, new_port: i32) -> nsresult { + debug_assert_mut!(url); + if url.cannot_be_a_base() { + return NS_ERROR_MALFORMED_URI; + } + + let port = match new_port { + new if new < 0 || u16::max_value() as i32 <= new => None, + new if Some(new as u16) == default_port(url.scheme()) => None, + new => Some(new as u16), + }; + try_or_malformed!(url.set_port(port)); + NS_OK +} + +#[no_mangle] +pub extern "C" fn mozurl_set_pathname(url: &mut MozURL, path: &nsACString) -> nsresult { + debug_assert_mut!(url); + let path = try_or_malformed!(str::from_utf8(path)); + quirks::set_pathname(url, path); + NS_OK +} + +#[no_mangle] +pub extern "C" fn mozurl_set_query(url: &mut MozURL, query: &nsACString) -> nsresult { + debug_assert_mut!(url); + let query = try_or_malformed!(str::from_utf8(query)); + quirks::set_search(url, query); + NS_OK +} + +#[no_mangle] +pub extern "C" fn mozurl_set_fragment(url: &mut MozURL, fragment: &nsACString) -> nsresult { + debug_assert_mut!(url); + let fragment = try_or_malformed!(str::from_utf8(fragment)); + quirks::set_hash(url, fragment); + NS_OK +} + +#[no_mangle] +pub extern "C" fn mozurl_sizeof(url: &MozURL) -> usize { + debug_assert_mut!(url); + mem::size_of::<MozURL>() + url.as_str().len() +} + +#[no_mangle] +pub extern "C" fn mozurl_common_base( + url1: &MozURL, + url2: &MozURL, + result: &mut *const MozURL, +) -> nsresult { + *result = ptr::null(); + if url1.url == url2.url { + RefPtr::new(url1).forget(result); + return NS_OK; + } + + if url1.scheme() != url2.scheme() + || url1.host() != url2.host() + || url1.username() != url2.username() + || url1.password() != url2.password() + || url1.port() != url2.port() + { + return NS_OK; + } + + match (url1.path_segments(), url2.path_segments()) { + (Some(path1), Some(path2)) => { + // Take the shared prefix of path segments + let mut url = url1.url.clone(); + if let Ok(mut segs) = url.path_segments_mut() { + segs.clear(); + segs.extend(path1.zip(path2).take_while(|&(a, b)| a == b).map(|p| p.0)); + } else { + return NS_OK; + } + + MozURL::from_url(url).forget(result); + NS_OK + } + _ => NS_OK, + } +} + +#[no_mangle] +pub extern "C" fn mozurl_relative( + url1: &MozURL, + url2: &MozURL, + result: &mut nsACString, +) -> nsresult { + if url1.url == url2.url { + result.truncate(); + return NS_OK; + } + + if url1.scheme() != url2.scheme() + || url1.host() != url2.host() + || url1.username() != url2.username() + || url1.password() != url2.password() + || url1.port() != url2.port() + { + result.assign(url2.as_ref()); + return NS_OK; + } + + match (url1.path_segments(), url2.path_segments()) { + (Some(mut path1), Some(mut path2)) => { + // Exhaust the part of the iterators that match + while let (Some(ref p1), Some(ref p2)) = (path1.next(), path2.next()) { + if p1 != p2 { + break; + } + } + + result.truncate(); + for _ in path1 { + result.append("../"); + } + for p2 in path2 { + result.append(p2); + result.append("/"); + } + } + _ => { + result.assign(url2.as_ref()); + } + } + NS_OK +} + +/// This type is used by nsStandardURL +#[no_mangle] +pub extern "C" fn rusturl_parse_ipv6addr(input: &nsACString, addr: &mut nsACString) -> nsresult { + let ip6 = try_or_malformed!(str::from_utf8(input)); + let host = try_or_malformed!(url::Host::parse(ip6)); + let _ = write!(addr, "{}", host); + NS_OK +} diff --git a/netwerk/base/netCore.h b/netwerk/base/netCore.h new file mode 100644 index 0000000000..258cc5cb58 --- /dev/null +++ b/netwerk/base/netCore.h @@ -0,0 +1,14 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef __netCore_h__ +#define __netCore_h__ + +#include "nsError.h" + +// Where most necko status messages come from: +#define NECKO_MSGS_URL "chrome://necko/locale/necko.properties" + +#endif // __netCore_h__ diff --git a/netwerk/base/nsASocketHandler.h b/netwerk/base/nsASocketHandler.h new file mode 100644 index 0000000000..95c847cdb0 --- /dev/null +++ b/netwerk/base/nsASocketHandler.h @@ -0,0 +1,93 @@ +/* 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/. */ + +#ifndef nsASocketHandler_h__ +#define nsASocketHandler_h__ + +// socket handler used by nsISocketTransportService. +// methods are only called on the socket thread. + +class nsASocketHandler : public nsISupports { + public: + nsASocketHandler() + : mCondition(NS_OK), + mPollFlags(0), + mPollTimeout(UINT16_MAX), + mIsPrivate(false) {} + + // + // this condition variable will be checked to determine if the socket + // handler should be detached. it must only be accessed on the socket + // thread. + // + nsresult mCondition; + + // + // these flags can only be modified on the socket transport thread. + // the socket transport service will check these flags before calling + // PR_Poll. + // + uint16_t mPollFlags; + + // + // this value specifies the maximum amount of time in seconds that may be + // spent waiting for activity on this socket. if this timeout is reached, + // then OnSocketReady will be called with outFlags = -1. + // + // the default value for this member is UINT16_MAX, which disables the + // timeout error checking. (i.e., a timeout value of UINT16_MAX is + // never reached.) + // + uint16_t mPollTimeout; + + bool mIsPrivate; + + // + // called to service a socket + // + // params: + // socketRef - socket identifier + // fd - socket file descriptor + // outFlags - value of PR_PollDesc::out_flags after PR_Poll returns + // or -1 if a timeout occurred + // + virtual void OnSocketReady(PRFileDesc* fd, int16_t outFlags) = 0; + + // + // called when a socket is no longer under the control of the socket + // transport service. the socket handler may close the socket at this + // point. after this call returns, the handler will no longer be owned + // by the socket transport service. + // + virtual void OnSocketDetached(PRFileDesc* fd) = 0; + + // + // called to determine if the socket is for a local peer. + // when used for server sockets, indicates if it only accepts local + // connections. + // + virtual void IsLocal(bool* aIsLocal) = 0; + + // + // called to determine if this socket should not be terminated when Gecko + // is turned offline. This is mostly useful for the debugging server + // socket. + // + virtual void KeepWhenOffline(bool* aKeepWhenOffline) { + *aKeepWhenOffline = false; + } + + // + // called when global pref for keepalive has changed. + // + virtual void OnKeepaliveEnabledPrefChange(bool aEnabled) {} + + // + // returns the number of bytes sent/transmitted over the socket + // + virtual uint64_t ByteCountSent() = 0; + virtual uint64_t ByteCountReceived() = 0; +}; + +#endif // !nsASocketHandler_h__ diff --git a/netwerk/base/nsAsyncRedirectVerifyHelper.cpp b/netwerk/base/nsAsyncRedirectVerifyHelper.cpp new file mode 100644 index 0000000000..d61c00414c --- /dev/null +++ b/netwerk/base/nsAsyncRedirectVerifyHelper.cpp @@ -0,0 +1,285 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "mozilla/Logging.h" +#include "mozilla/SpinEventLoopUntil.h" +#include "nsAsyncRedirectVerifyHelper.h" +#include "nsThreadUtils.h" +#include "nsNetUtil.h" + +#include "nsIOService.h" +#include "nsIChannel.h" +#include "nsIHttpChannelInternal.h" +#include "nsIAsyncVerifyRedirectCallback.h" +#include "nsILoadInfo.h" + +namespace mozilla { +namespace net { + +static LazyLogModule gRedirectLog("nsRedirect"); +#undef LOG +#define LOG(args) MOZ_LOG(gRedirectLog, LogLevel::Debug, args) + +NS_IMPL_ISUPPORTS(nsAsyncRedirectVerifyHelper, nsIAsyncVerifyRedirectCallback, + nsIRunnable, nsINamed) + +class nsAsyncVerifyRedirectCallbackEvent : public Runnable { + public: + nsAsyncVerifyRedirectCallbackEvent(nsIAsyncVerifyRedirectCallback* cb, + nsresult result) + : Runnable("nsAsyncVerifyRedirectCallbackEvent"), + mCallback(cb), + mResult(result) {} + + NS_IMETHOD Run() override { + LOG( + ("nsAsyncVerifyRedirectCallbackEvent::Run() " + "callback to %p with result %" PRIx32, + mCallback.get(), static_cast<uint32_t>(mResult))); + (void)mCallback->OnRedirectVerifyCallback(mResult); + return NS_OK; + } + + private: + nsCOMPtr<nsIAsyncVerifyRedirectCallback> mCallback; + nsresult mResult; +}; + +nsAsyncRedirectVerifyHelper::nsAsyncRedirectVerifyHelper() + : mFlags(0), + mWaitingForRedirectCallback(false), + mCallbackInitiated(false), + mExpectedCallbacks(0), + mResult(NS_OK) {} + +nsAsyncRedirectVerifyHelper::~nsAsyncRedirectVerifyHelper() { + NS_ASSERTION(NS_FAILED(mResult) || mExpectedCallbacks == 0, + "Did not receive all required callbacks!"); +} + +nsresult nsAsyncRedirectVerifyHelper::Init( + nsIChannel* oldChan, nsIChannel* newChan, uint32_t flags, + nsIEventTarget* mainThreadEventTarget, bool synchronize) { + LOG( + ("nsAsyncRedirectVerifyHelper::Init() " + "oldChan=%p newChan=%p", + oldChan, newChan)); + mOldChan = oldChan; + mNewChan = newChan; + mFlags = flags; + mCallbackEventTarget = NS_IsMainThread() && mainThreadEventTarget + ? mainThreadEventTarget + : GetCurrentEventTarget(); + + if (!(flags & (nsIChannelEventSink::REDIRECT_INTERNAL | + nsIChannelEventSink::REDIRECT_STS_UPGRADE))) { + nsCOMPtr<nsILoadInfo> loadInfo = oldChan->LoadInfo(); + if (loadInfo->GetDontFollowRedirects()) { + ExplicitCallback(NS_BINDING_ABORTED); + return NS_OK; + } + } + + if (synchronize) mWaitingForRedirectCallback = true; + + nsCOMPtr<nsIRunnable> runnable = this; + nsresult rv; + rv = mainThreadEventTarget + ? mainThreadEventTarget->Dispatch(runnable.forget()) + : GetMainThreadEventTarget()->Dispatch(runnable.forget()); + NS_ENSURE_SUCCESS(rv, rv); + + if (synchronize) { + if (!SpinEventLoopUntil([&]() { return !mWaitingForRedirectCallback; })) { + return NS_ERROR_UNEXPECTED; + } + } + + return NS_OK; +} + +NS_IMETHODIMP +nsAsyncRedirectVerifyHelper::OnRedirectVerifyCallback(nsresult result) { + LOG( + ("nsAsyncRedirectVerifyHelper::OnRedirectVerifyCallback() " + "result=%" PRIx32 " expectedCBs=%u mResult=%" PRIx32, + static_cast<uint32_t>(result), mExpectedCallbacks, + static_cast<uint32_t>(mResult))); + + MOZ_DIAGNOSTIC_ASSERT( + mExpectedCallbacks > 0, + "OnRedirectVerifyCallback called more times than expected"); + if (mExpectedCallbacks <= 0) { + return NS_ERROR_UNEXPECTED; + } + + --mExpectedCallbacks; + + // If response indicates failure we may call back immediately + if (NS_FAILED(result)) { + // We chose to store the first failure-value (as opposed to the last) + if (NS_SUCCEEDED(mResult)) mResult = result; + + // If InitCallback() has been called, just invoke the callback and + // return. Otherwise it will be invoked from InitCallback() + if (mCallbackInitiated) { + ExplicitCallback(mResult); + return NS_OK; + } + } + + // If the expected-counter is in balance and InitCallback() was called, all + // sinks have agreed that the redirect is ok and we can invoke our callback + if (mCallbackInitiated && mExpectedCallbacks == 0) { + ExplicitCallback(mResult); + } + + return NS_OK; +} + +nsresult nsAsyncRedirectVerifyHelper::DelegateOnChannelRedirect( + nsIChannelEventSink* sink, nsIChannel* oldChannel, nsIChannel* newChannel, + uint32_t flags) { + LOG( + ("nsAsyncRedirectVerifyHelper::DelegateOnChannelRedirect() " + "sink=%p expectedCBs=%u mResult=%" PRIx32, + sink, mExpectedCallbacks, static_cast<uint32_t>(mResult))); + + ++mExpectedCallbacks; + + if (IsOldChannelCanceled()) { + LOG( + (" old channel has been canceled, cancel the redirect by " + "emulating OnRedirectVerifyCallback...")); + (void)OnRedirectVerifyCallback(NS_BINDING_ABORTED); + return NS_BINDING_ABORTED; + } + + nsresult rv = + sink->AsyncOnChannelRedirect(oldChannel, newChannel, flags, this); + + LOG((" result=%" PRIx32 " expectedCBs=%u", static_cast<uint32_t>(rv), + mExpectedCallbacks)); + + // If the sink returns failure from this call the redirect is vetoed. We + // emulate a callback from the sink in this case in order to perform all + // the necessary logic. + if (NS_FAILED(rv)) { + LOG((" emulating OnRedirectVerifyCallback...")); + (void)OnRedirectVerifyCallback(rv); + } + + return rv; // Return the actual status since our caller may need it +} + +void nsAsyncRedirectVerifyHelper::ExplicitCallback(nsresult result) { + LOG( + ("nsAsyncRedirectVerifyHelper::ExplicitCallback() " + "result=%" PRIx32 + " expectedCBs=%u mCallbackInitiated=%u mResult=%" PRIx32, + static_cast<uint32_t>(result), mExpectedCallbacks, mCallbackInitiated, + static_cast<uint32_t>(mResult))); + + nsCOMPtr<nsIAsyncVerifyRedirectCallback> callback( + do_QueryInterface(mOldChan)); + + if (!callback || !mCallbackEventTarget) { + LOG( + ("nsAsyncRedirectVerifyHelper::ExplicitCallback() " + "callback=%p mCallbackEventTarget=%p", + callback.get(), mCallbackEventTarget.get())); + return; + } + + mCallbackInitiated = false; // reset to ensure only one callback + mWaitingForRedirectCallback = false; + + // Now, dispatch the callback on the event-target which called Init() + nsCOMPtr<nsIRunnable> event = + new nsAsyncVerifyRedirectCallbackEvent(callback, result); + if (!event) { + NS_WARNING( + "nsAsyncRedirectVerifyHelper::ExplicitCallback() " + "failed creating callback event!"); + return; + } + nsresult rv = mCallbackEventTarget->Dispatch(event, NS_DISPATCH_NORMAL); + if (NS_FAILED(rv)) { + NS_WARNING( + "nsAsyncRedirectVerifyHelper::ExplicitCallback() " + "failed dispatching callback event!"); + } else { + LOG( + ("nsAsyncRedirectVerifyHelper::ExplicitCallback() " + "dispatched callback event=%p", + event.get())); + } +} + +void nsAsyncRedirectVerifyHelper::InitCallback() { + LOG( + ("nsAsyncRedirectVerifyHelper::InitCallback() " + "expectedCBs=%d mResult=%" PRIx32, + mExpectedCallbacks, static_cast<uint32_t>(mResult))); + + mCallbackInitiated = true; + + // Invoke the callback if we are done + if (mExpectedCallbacks == 0) ExplicitCallback(mResult); +} + +NS_IMETHODIMP +nsAsyncRedirectVerifyHelper::GetName(nsACString& aName) { + aName.AssignLiteral("nsAsyncRedirectVerifyHelper"); + return NS_OK; +} + +NS_IMETHODIMP +nsAsyncRedirectVerifyHelper::Run() { + /* If the channel got canceled after it fired AsyncOnChannelRedirect + * and before we got here, mostly because docloader load has been canceled, + * we must completely ignore this notification and prevent any further + * notification. + */ + if (IsOldChannelCanceled()) { + ExplicitCallback(NS_BINDING_ABORTED); + return NS_OK; + } + + // First, the global observer + NS_ASSERTION(gIOService, "Must have an IO service at this point"); + LOG(("nsAsyncRedirectVerifyHelper::Run() calling gIOService...")); + nsresult rv = + gIOService->AsyncOnChannelRedirect(mOldChan, mNewChan, mFlags, this); + if (NS_FAILED(rv)) { + ExplicitCallback(rv); + return NS_OK; + } + + // Now, the per-channel observers + nsCOMPtr<nsIChannelEventSink> sink; + NS_QueryNotificationCallbacks(mOldChan, sink); + if (sink) { + LOG(("nsAsyncRedirectVerifyHelper::Run() calling sink...")); + rv = DelegateOnChannelRedirect(sink, mOldChan, mNewChan, mFlags); + } + + // All invocations to AsyncOnChannelRedirect has been done - call + // InitCallback() to flag this + InitCallback(); + return NS_OK; +} + +bool nsAsyncRedirectVerifyHelper::IsOldChannelCanceled() { + if (!mOldChan) { + return false; + } + bool canceled; + nsresult rv = mOldChan->GetCanceled(&canceled); + return NS_SUCCEEDED(rv) && canceled; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/nsAsyncRedirectVerifyHelper.h b/netwerk/base/nsAsyncRedirectVerifyHelper.h new file mode 100644 index 0000000000..7f0a16194f --- /dev/null +++ b/netwerk/base/nsAsyncRedirectVerifyHelper.h @@ -0,0 +1,121 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef nsAsyncRedirectVerifyHelper_h +#define nsAsyncRedirectVerifyHelper_h + +#include "nsIRunnable.h" +#include "nsIChannelEventSink.h" +#include "nsIAsyncVerifyRedirectCallback.h" +#include "nsINamed.h" +#include "nsCOMPtr.h" +#include "nsCycleCollectionParticipant.h" +#include "mozilla/Attributes.h" + +class nsIChannel; + +namespace mozilla { +namespace net { + +/** + * This class simplifies call of OnChannelRedirect of IOService and + * the sink bound with the channel being redirected while the result of + * redirect decision is returned through the callback. + */ +class nsAsyncRedirectVerifyHelper final + : public nsIRunnable, + public nsINamed, + public nsIAsyncVerifyRedirectCallback { + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIRUNNABLE + NS_DECL_NSINAMED + NS_DECL_NSIASYNCVERIFYREDIRECTCALLBACK + + public: + nsAsyncRedirectVerifyHelper(); + + /* + * Calls AsyncOnChannelRedirect() on the given sink with the given + * channels and flags. Keeps track of number of async callbacks to expect. + */ + nsresult DelegateOnChannelRedirect(nsIChannelEventSink* sink, + nsIChannel* oldChannel, + nsIChannel* newChannel, uint32_t flags); + + /** + * Initialize and run the chain of AsyncOnChannelRedirect calls. OldChannel + * is QI'ed for nsIAsyncVerifyRedirectCallback. The result of the redirect + * decision is passed through this interface back to the oldChannel. + * + * @param oldChan + * channel being redirected, MUST implement + * nsIAsyncVerifyRedirectCallback + * @param newChan + * target of the redirect channel + * @param flags + * redirect flags + * @param mainThreadEventTarget + * a labeled event target for dispatching runnables + * @param synchronize + * set to TRUE if you want the Init method wait synchronously for + * all redirect callbacks + */ + nsresult Init(nsIChannel* oldChan, nsIChannel* newChan, uint32_t flags, + nsIEventTarget* mainThreadEventTarget, + bool synchronize = false); + + protected: + nsCOMPtr<nsIChannel> mOldChan; + nsCOMPtr<nsIChannel> mNewChan; + uint32_t mFlags; + bool mWaitingForRedirectCallback; + nsCOMPtr<nsIEventTarget> mCallbackEventTarget; + bool mCallbackInitiated; + int32_t mExpectedCallbacks; + nsresult mResult; // value passed to callback + + void InitCallback(); + + /** + * Calls back to |oldChan| as described in Init() + */ + void ExplicitCallback(nsresult result); + + private: + ~nsAsyncRedirectVerifyHelper(); + + bool IsOldChannelCanceled(); +}; + +/* + * Helper to make the call-stack handle some control-flow for us + */ +class nsAsyncRedirectAutoCallback { + public: + explicit nsAsyncRedirectAutoCallback( + nsIAsyncVerifyRedirectCallback* aCallback) + : mCallback(aCallback) { + mResult = NS_OK; + } + ~nsAsyncRedirectAutoCallback() { + if (mCallback) mCallback->OnRedirectVerifyCallback(mResult); + } + /* + * Call this is you want it to call back with a different result-code + */ + void SetResult(nsresult aRes) { mResult = aRes; } + /* + * Call this is you want to avoid the callback + */ + void DontCallback() { mCallback = nullptr; } + + private: + nsIAsyncVerifyRedirectCallback* mCallback; + nsresult mResult; +}; + +} // namespace net +} // namespace mozilla +#endif diff --git a/netwerk/base/nsAsyncStreamCopier.cpp b/netwerk/base/nsAsyncStreamCopier.cpp new file mode 100644 index 0000000000..eea2266ca6 --- /dev/null +++ b/netwerk/base/nsAsyncStreamCopier.cpp @@ -0,0 +1,392 @@ +/* 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 "nsAsyncStreamCopier.h" +#include "nsIOService.h" +#include "nsIEventTarget.h" +#include "nsStreamUtils.h" +#include "nsThreadUtils.h" +#include "nsNetUtil.h" +#include "nsNetCID.h" +#include "nsIBufferedStreams.h" +#include "nsIRequestObserver.h" +#include "mozilla/Logging.h" + +using namespace mozilla; +using namespace mozilla::net; + +#undef LOG +// +// MOZ_LOG=nsStreamCopier:5 +// +static LazyLogModule gStreamCopierLog("nsStreamCopier"); +#define LOG(args) MOZ_LOG(gStreamCopierLog, mozilla::LogLevel::Debug, args) + +/** + * An event used to perform initialization off the main thread. + */ +class AsyncApplyBufferingPolicyEvent final : public Runnable { + public: + /** + * @param aCopier + * The nsAsyncStreamCopier requesting the information. + */ + explicit AsyncApplyBufferingPolicyEvent(nsAsyncStreamCopier* aCopier) + : mozilla::Runnable("AsyncApplyBufferingPolicyEvent"), + mCopier(aCopier), + mTarget(GetCurrentEventTarget()) {} + + NS_IMETHOD Run() override { + nsresult rv = mCopier->ApplyBufferingPolicy(); + if (NS_FAILED(rv)) { + mCopier->Cancel(rv); + return NS_OK; + } + + rv = mTarget->Dispatch( + NewRunnableMethod("nsAsyncStreamCopier::AsyncCopyInternal", mCopier, + &nsAsyncStreamCopier::AsyncCopyInternal), + NS_DISPATCH_NORMAL); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + + if (NS_FAILED(rv)) { + mCopier->Cancel(rv); + } + return NS_OK; + } + + private: + RefPtr<nsAsyncStreamCopier> mCopier; + nsCOMPtr<nsIEventTarget> mTarget; +}; + +//----------------------------------------------------------------------------- + +nsAsyncStreamCopier::nsAsyncStreamCopier() + : mLock("nsAsyncStreamCopier.mLock"), + mMode(NS_ASYNCCOPY_VIA_READSEGMENTS), + mChunkSize(nsIOService::gDefaultSegmentSize), + mStatus(NS_OK), + mIsPending(false), + mCloseSource{false}, + mCloseSink{false}, + mShouldSniffBuffering(false) { + LOG(("Creating nsAsyncStreamCopier @%p\n", this)); +} + +nsAsyncStreamCopier::~nsAsyncStreamCopier() { + LOG(("Destroying nsAsyncStreamCopier @%p\n", this)); +} + +bool nsAsyncStreamCopier::IsComplete(nsresult* status) { + MutexAutoLock lock(mLock); + if (status) *status = mStatus; + return !mIsPending; +} + +nsIRequest* nsAsyncStreamCopier::AsRequest() { + return static_cast<nsIRequest*>(static_cast<nsIAsyncStreamCopier*>(this)); +} + +void nsAsyncStreamCopier::Complete(nsresult status) { + LOG(("nsAsyncStreamCopier::Complete [this=%p status=%" PRIx32 "]\n", this, + static_cast<uint32_t>(status))); + + nsCOMPtr<nsIRequestObserver> observer; + nsCOMPtr<nsISupports> ctx; + { + MutexAutoLock lock(mLock); + mCopierCtx = nullptr; + + if (mIsPending) { + mIsPending = false; + mStatus = status; + + // setup OnStopRequest callback and release references... + observer = mObserver; + mObserver = nullptr; + } + } + + if (observer) { + LOG((" calling OnStopRequest [status=%" PRIx32 "]\n", + static_cast<uint32_t>(status))); + observer->OnStopRequest(AsRequest(), status); + } +} + +void nsAsyncStreamCopier::OnAsyncCopyComplete(void* closure, nsresult status) { + // AddRef'd in AsyncCopy. Will be released at the end of the method. + RefPtr<nsAsyncStreamCopier> self = dont_AddRef((nsAsyncStreamCopier*)closure); + self->Complete(status); +} + +//----------------------------------------------------------------------------- +// nsISupports + +// We cannot use simply NS_IMPL_ISUPPORTSx as both +// nsIAsyncStreamCopier and nsIAsyncStreamCopier2 implement nsIRequest + +NS_IMPL_ADDREF(nsAsyncStreamCopier) +NS_IMPL_RELEASE(nsAsyncStreamCopier) +NS_INTERFACE_TABLE_HEAD(nsAsyncStreamCopier) + NS_INTERFACE_TABLE_BEGIN + NS_INTERFACE_TABLE_ENTRY(nsAsyncStreamCopier, nsIAsyncStreamCopier) + NS_INTERFACE_TABLE_ENTRY(nsAsyncStreamCopier, nsIAsyncStreamCopier2) + NS_INTERFACE_TABLE_ENTRY_AMBIGUOUS(nsAsyncStreamCopier, nsIRequest, + nsIAsyncStreamCopier) + NS_INTERFACE_TABLE_ENTRY_AMBIGUOUS(nsAsyncStreamCopier, nsISupports, + nsIAsyncStreamCopier) + NS_INTERFACE_TABLE_END +NS_INTERFACE_TABLE_TAIL + +//----------------------------------------------------------------------------- +// nsIRequest + +NS_IMETHODIMP +nsAsyncStreamCopier::GetName(nsACString& name) { + name.Truncate(); + return NS_OK; +} + +NS_IMETHODIMP +nsAsyncStreamCopier::IsPending(bool* result) { + *result = !IsComplete(); + return NS_OK; +} + +NS_IMETHODIMP +nsAsyncStreamCopier::GetStatus(nsresult* status) { + IsComplete(status); + return NS_OK; +} + +NS_IMETHODIMP +nsAsyncStreamCopier::Cancel(nsresult status) { + nsCOMPtr<nsISupports> copierCtx; + { + MutexAutoLock lock(mLock); + if (!mIsPending) return NS_OK; + copierCtx.swap(mCopierCtx); + } + + if (NS_SUCCEEDED(status)) { + NS_WARNING("cancel with non-failure status code"); + status = NS_BASE_STREAM_CLOSED; + } + + if (copierCtx) NS_CancelAsyncCopy(copierCtx, status); + + return NS_OK; +} + +NS_IMETHODIMP +nsAsyncStreamCopier::Suspend() { + MOZ_ASSERT_UNREACHABLE("nsAsyncStreamCopier::Suspend"); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsAsyncStreamCopier::Resume() { + MOZ_ASSERT_UNREACHABLE("nsAsyncStreamCopier::Resume"); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsAsyncStreamCopier::GetLoadFlags(nsLoadFlags* aLoadFlags) { + *aLoadFlags = LOAD_NORMAL; + return NS_OK; +} + +NS_IMETHODIMP +nsAsyncStreamCopier::SetLoadFlags(nsLoadFlags aLoadFlags) { return NS_OK; } + +NS_IMETHODIMP +nsAsyncStreamCopier::GetTRRMode(nsIRequest::TRRMode* aTRRMode) { + return nsIAsyncStreamCopier::GetTRRModeImpl(aTRRMode); +} + +NS_IMETHODIMP +nsAsyncStreamCopier::SetTRRMode(nsIRequest::TRRMode aTRRMode) { + return nsIAsyncStreamCopier::SetTRRModeImpl(aTRRMode); +} + +NS_IMETHODIMP +nsAsyncStreamCopier::GetLoadGroup(nsILoadGroup** aLoadGroup) { + *aLoadGroup = nullptr; + return NS_OK; +} + +NS_IMETHODIMP +nsAsyncStreamCopier::SetLoadGroup(nsILoadGroup* aLoadGroup) { return NS_OK; } + +nsresult nsAsyncStreamCopier::InitInternal(nsIInputStream* source, + nsIOutputStream* sink, + nsIEventTarget* target, + uint32_t chunkSize, bool closeSource, + bool closeSink) { + NS_ASSERTION(!mSource && !mSink, "Init() called more than once"); + if (chunkSize == 0) { + chunkSize = nsIOService::gDefaultSegmentSize; + } + mChunkSize = chunkSize; + + mSource = source; + mSink = sink; + mCloseSource = closeSource; + mCloseSink = closeSink; + + if (target) { + mTarget = target; + } else { + nsresult rv; + mTarget = do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID, &rv); + if (NS_FAILED(rv)) { + return rv; + } + } + + return NS_OK; +} + +//----------------------------------------------------------------------------- +// nsIAsyncStreamCopier + +NS_IMETHODIMP +nsAsyncStreamCopier::Init(nsIInputStream* source, nsIOutputStream* sink, + nsIEventTarget* target, bool sourceBuffered, + bool sinkBuffered, uint32_t chunkSize, + bool closeSource, bool closeSink) { + NS_ASSERTION(sourceBuffered || sinkBuffered, + "at least one stream must be buffered"); + mMode = sourceBuffered ? NS_ASYNCCOPY_VIA_READSEGMENTS + : NS_ASYNCCOPY_VIA_WRITESEGMENTS; + + return InitInternal(source, sink, target, chunkSize, closeSource, closeSink); +} + +//----------------------------------------------------------------------------- +// nsIAsyncStreamCopier2 + +NS_IMETHODIMP +nsAsyncStreamCopier::Init(nsIInputStream* source, nsIOutputStream* sink, + nsIEventTarget* target, uint32_t chunkSize, + bool closeSource, bool closeSink) { + mShouldSniffBuffering = true; + + return InitInternal(source, sink, target, chunkSize, closeSource, closeSink); +} + +/** + * Detect whether the input or the output stream is buffered, + * bufferize one of them if neither is buffered. + */ +nsresult nsAsyncStreamCopier::ApplyBufferingPolicy() { + // This function causes I/O, it must not be executed on the main + // thread. + MOZ_ASSERT(!NS_IsMainThread()); + + if (NS_OutputStreamIsBuffered(mSink)) { + // Sink is buffered, no need to perform additional buffering + mMode = NS_ASYNCCOPY_VIA_WRITESEGMENTS; + return NS_OK; + } + if (NS_InputStreamIsBuffered(mSource)) { + // Source is buffered, no need to perform additional buffering + mMode = NS_ASYNCCOPY_VIA_READSEGMENTS; + return NS_OK; + } + + // No buffering, let's buffer the sink + nsresult rv; + nsCOMPtr<nsIBufferedOutputStream> sink = + do_CreateInstance(NS_BUFFEREDOUTPUTSTREAM_CONTRACTID, &rv); + if (NS_FAILED(rv)) { + return rv; + } + + rv = sink->Init(mSink, mChunkSize); + if (NS_FAILED(rv)) { + return rv; + } + + mMode = NS_ASYNCCOPY_VIA_WRITESEGMENTS; + mSink = sink; + return NS_OK; +} + +//----------------------------------------------------------------------------- +// Both nsIAsyncStreamCopier and nsIAsyncStreamCopier2 + +NS_IMETHODIMP +nsAsyncStreamCopier::AsyncCopy(nsIRequestObserver* observer, nsISupports* ctx) { + LOG(("nsAsyncStreamCopier::AsyncCopy [this=%p observer=%p]\n", this, + observer)); + + NS_ASSERTION(mSource && mSink, "not initialized"); + nsresult rv; + + if (observer) { + // build proxy for observer events + rv = NS_NewRequestObserverProxy(getter_AddRefs(mObserver), observer, ctx); + if (NS_FAILED(rv)) return rv; + } + + // from this point forward, AsyncCopy is going to return NS_OK. any errors + // will be reported via OnStopRequest. + mIsPending = true; + + if (mObserver) { + rv = mObserver->OnStartRequest(AsRequest()); + if (NS_FAILED(rv)) Cancel(rv); + } + + if (!mShouldSniffBuffering) { + // No buffer sniffing required, let's proceed + AsyncCopyInternal(); + return NS_OK; + } + + if (NS_IsMainThread()) { + // Don't perform buffer sniffing on the main thread + nsCOMPtr<nsIRunnable> event = new AsyncApplyBufferingPolicyEvent(this); + rv = mTarget->Dispatch(event, NS_DISPATCH_NORMAL); + if (NS_FAILED(rv)) { + Cancel(rv); + } + return NS_OK; + } + + // We're not going to block the main thread, so let's sniff here + rv = ApplyBufferingPolicy(); + if (NS_FAILED(rv)) { + Cancel(rv); + } + AsyncCopyInternal(); + return NS_OK; +} + +// Launch async copy. +// All errors are reported through the observer. +void nsAsyncStreamCopier::AsyncCopyInternal() { + MOZ_ASSERT(mMode == NS_ASYNCCOPY_VIA_READSEGMENTS || + mMode == NS_ASYNCCOPY_VIA_WRITESEGMENTS); + + nsresult rv; + // We want to receive progress notifications; release happens in + // OnAsyncCopyComplete. + RefPtr<nsAsyncStreamCopier> self = this; + { + MutexAutoLock lock(mLock); + rv = NS_AsyncCopy(mSource, mSink, mTarget, mMode, mChunkSize, + OnAsyncCopyComplete, this, mCloseSource, mCloseSink, + getter_AddRefs(mCopierCtx)); + } + if (NS_FAILED(rv)) { + Cancel(rv); + return; // release self + } + + Unused << self.forget(); // Will be released in OnAsyncCopyComplete +} diff --git a/netwerk/base/nsAsyncStreamCopier.h b/netwerk/base/nsAsyncStreamCopier.h new file mode 100644 index 0000000000..fe3a15c46d --- /dev/null +++ b/netwerk/base/nsAsyncStreamCopier.h @@ -0,0 +1,76 @@ +/* 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/. */ + +#ifndef nsAsyncStreamCopier_h__ +#define nsAsyncStreamCopier_h__ + +#include "nsIAsyncStreamCopier.h" +#include "nsIAsyncStreamCopier2.h" +#include "mozilla/Mutex.h" +#include "nsStreamUtils.h" +#include "nsCOMPtr.h" + +class nsIRequestObserver; + +//----------------------------------------------------------------------------- + +class nsAsyncStreamCopier final : public nsIAsyncStreamCopier, + nsIAsyncStreamCopier2 { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIREQUEST + NS_DECL_NSIASYNCSTREAMCOPIER + + // nsIAsyncStreamCopier2 + // We declare it by hand instead of NS_DECL_NSIASYNCSTREAMCOPIER2 + // as nsIAsyncStreamCopier2 duplicates methods of nsIAsyncStreamCopier + NS_IMETHOD Init(nsIInputStream* aSource, nsIOutputStream* aSink, + nsIEventTarget* aTarget, uint32_t aChunkSize, + bool aCloseSource, bool aCloseSink) override; + + nsAsyncStreamCopier(); + + //------------------------------------------------------------------------- + // these methods may be called on any thread + + bool IsComplete(nsresult* status = nullptr); + void Complete(nsresult status); + + private: + virtual ~nsAsyncStreamCopier(); + + nsresult InitInternal(nsIInputStream* source, nsIOutputStream* sink, + nsIEventTarget* target, uint32_t chunkSize, + bool closeSource, bool closeSink); + + static void OnAsyncCopyComplete(void*, nsresult); + + void AsyncCopyInternal(); + nsresult ApplyBufferingPolicy(); + nsIRequest* AsRequest(); + + nsCOMPtr<nsIInputStream> mSource; + nsCOMPtr<nsIOutputStream> mSink; + + nsCOMPtr<nsIRequestObserver> mObserver; + + nsCOMPtr<nsIEventTarget> mTarget; + + nsCOMPtr<nsISupports> mCopierCtx; + + mozilla::Mutex mLock; + + nsAsyncCopyMode mMode; + uint32_t mChunkSize; + nsresult mStatus; + bool mIsPending; + bool mCloseSource; + bool mCloseSink; + bool mShouldSniffBuffering; + + friend class ProceedWithAsyncCopy; + friend class AsyncApplyBufferingPolicyEvent; +}; + +#endif // !nsAsyncStreamCopier_h__ diff --git a/netwerk/base/nsAuthInformationHolder.cpp b/netwerk/base/nsAuthInformationHolder.cpp new file mode 100644 index 0000000000..11cf7626ce --- /dev/null +++ b/netwerk/base/nsAuthInformationHolder.cpp @@ -0,0 +1,61 @@ +/* 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 "nsAuthInformationHolder.h" + +NS_IMPL_ISUPPORTS(nsAuthInformationHolder, nsIAuthInformation) + +NS_IMETHODIMP +nsAuthInformationHolder::GetFlags(uint32_t* aFlags) { + *aFlags = mFlags; + return NS_OK; +} + +NS_IMETHODIMP +nsAuthInformationHolder::GetRealm(nsAString& aRealm) { + aRealm = mRealm; + return NS_OK; +} + +NS_IMETHODIMP +nsAuthInformationHolder::GetAuthenticationScheme(nsACString& aScheme) { + aScheme = mAuthType; + return NS_OK; +} + +NS_IMETHODIMP +nsAuthInformationHolder::GetUsername(nsAString& aUserName) { + aUserName = mUser; + return NS_OK; +} + +NS_IMETHODIMP +nsAuthInformationHolder::SetUsername(const nsAString& aUserName) { + if (!(mFlags & ONLY_PASSWORD)) mUser = aUserName; + return NS_OK; +} + +NS_IMETHODIMP +nsAuthInformationHolder::GetPassword(nsAString& aPassword) { + aPassword = mPassword; + return NS_OK; +} + +NS_IMETHODIMP +nsAuthInformationHolder::SetPassword(const nsAString& aPassword) { + mPassword = aPassword; + return NS_OK; +} + +NS_IMETHODIMP +nsAuthInformationHolder::GetDomain(nsAString& aDomain) { + aDomain = mDomain; + return NS_OK; +} + +NS_IMETHODIMP +nsAuthInformationHolder::SetDomain(const nsAString& aDomain) { + if (mFlags & NEED_DOMAIN) mDomain = aDomain; + return NS_OK; +} diff --git a/netwerk/base/nsAuthInformationHolder.h b/netwerk/base/nsAuthInformationHolder.h new file mode 100644 index 0000000000..866586584d --- /dev/null +++ b/netwerk/base/nsAuthInformationHolder.h @@ -0,0 +1,44 @@ +/* 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/. */ + +#ifndef NSAUTHINFORMATIONHOLDER_H_ +#define NSAUTHINFORMATIONHOLDER_H_ + +#include "nsIAuthInformation.h" +#include "nsString.h" + +class nsAuthInformationHolder : public nsIAuthInformation { + protected: + virtual ~nsAuthInformationHolder() = default; + + public: + // aAuthType must be ASCII + nsAuthInformationHolder(uint32_t aFlags, const nsString& aRealm, + const nsCString& aAuthType) + : mFlags(aFlags), mRealm(aRealm), mAuthType(aAuthType) {} + + NS_DECL_ISUPPORTS + NS_DECL_NSIAUTHINFORMATION + + const nsString& User() const { return mUser; } + const nsString& Password() const { return mPassword; } + const nsString& Domain() const { return mDomain; } + + /** + * This method can be used to initialize the username when the + * ONLY_PASSWORD flag is set. + */ + void SetUserInternal(const nsString& aUsername) { mUser = aUsername; } + + private: + nsString mUser; + nsString mPassword; + nsString mDomain; + + uint32_t mFlags; + nsString mRealm; + nsCString mAuthType; +}; + +#endif diff --git a/netwerk/base/nsBase64Encoder.cpp b/netwerk/base/nsBase64Encoder.cpp new file mode 100644 index 0000000000..2757900b4d --- /dev/null +++ b/netwerk/base/nsBase64Encoder.cpp @@ -0,0 +1,51 @@ +/* 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 "nsBase64Encoder.h" + +#include "mozilla/Base64.h" + +NS_IMPL_ISUPPORTS(nsBase64Encoder, nsIOutputStream) + +NS_IMETHODIMP +nsBase64Encoder::Close() { return NS_OK; } + +NS_IMETHODIMP +nsBase64Encoder::Flush() { return NS_OK; } + +NS_IMETHODIMP +nsBase64Encoder::Write(const char* aBuf, uint32_t aCount, uint32_t* _retval) { + mData.Append(aBuf, aCount); + *_retval = aCount; + return NS_OK; +} + +NS_IMETHODIMP +nsBase64Encoder::WriteFrom(nsIInputStream* aStream, uint32_t aCount, + uint32_t* _retval) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsBase64Encoder::WriteSegments(nsReadSegmentFun aReader, void* aClosure, + uint32_t aCount, uint32_t* _retval) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsBase64Encoder::IsNonBlocking(bool* aNonBlocking) { + *aNonBlocking = false; + return NS_OK; +} + +nsresult nsBase64Encoder::Finish(nsACString& result) { + nsresult rv = mozilla::Base64Encode(mData, result); + if (NS_FAILED(rv)) { + return rv; + } + + // Free unneeded memory and allow reusing the object + mData.Truncate(); + return NS_OK; +} diff --git a/netwerk/base/nsBase64Encoder.h b/netwerk/base/nsBase64Encoder.h new file mode 100644 index 0000000000..b74d3c9b5a --- /dev/null +++ b/netwerk/base/nsBase64Encoder.h @@ -0,0 +1,33 @@ +/* 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/. */ + +#ifndef NSBASE64ENCODER_H_ +#define NSBASE64ENCODER_H_ + +#include "nsIOutputStream.h" +#include "nsString.h" +#include "mozilla/Attributes.h" + +/** + * A base64 encoder. Usage: Instantiate class, write to it using + * Write(), then call Finish() to get the base64-encoded data. + */ +class nsBase64Encoder final : public nsIOutputStream { + public: + nsBase64Encoder() = default; + + NS_DECL_ISUPPORTS + NS_DECL_NSIOUTPUTSTREAM + + nsresult Finish(nsACString& _result); + + private: + ~nsBase64Encoder() = default; + + /// The data written to this stream. nsCString can deal fine with + /// binary data. + nsCString mData; +}; + +#endif diff --git a/netwerk/base/nsBaseChannel.cpp b/netwerk/base/nsBaseChannel.cpp new file mode 100644 index 0000000000..877d20708e --- /dev/null +++ b/netwerk/base/nsBaseChannel.cpp @@ -0,0 +1,978 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set sw=2 sts=2 ts=8 et tw=80 : */ +/* 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 "nsBaseChannel.h" +#include "nsContentUtils.h" +#include "nsURLHelper.h" +#include "nsNetCID.h" +#include "nsMimeTypes.h" +#include "nsUnknownDecoder.h" +#include "nsIScriptSecurityManager.h" +#include "nsMimeTypes.h" +#include "nsIChannelEventSink.h" +#include "nsIStreamConverterService.h" +#include "nsChannelClassifier.h" +#include "nsAsyncRedirectVerifyHelper.h" +#include "nsProxyRelease.h" +#include "nsXULAppAPI.h" +#include "nsContentSecurityManager.h" +#include "LoadInfo.h" +#include "nsServiceManagerUtils.h" +#include "nsRedirectHistoryEntry.h" +#include "mozilla/AntiTrackingUtils.h" +#include "mozilla/BasePrincipal.h" + +using namespace mozilla; + +// This class is used to suspend a request across a function scope. +class ScopedRequestSuspender { + public: + explicit ScopedRequestSuspender(nsIRequest* request) : mRequest(request) { + if (mRequest && NS_FAILED(mRequest->Suspend())) { + NS_WARNING("Couldn't suspend pump"); + mRequest = nullptr; + } + } + ~ScopedRequestSuspender() { + if (mRequest) mRequest->Resume(); + } + + private: + nsIRequest* mRequest; +}; + +// Used to suspend data events from mRequest within a function scope. This is +// usually needed when a function makes callbacks that could process events. +#define SUSPEND_PUMP_FOR_SCOPE() \ + ScopedRequestSuspender pump_suspender__(mRequest) + +//----------------------------------------------------------------------------- +// nsBaseChannel + +nsBaseChannel::nsBaseChannel() + : NeckoTargetHolder(nullptr), + mPumpingData(false), + mLoadFlags(LOAD_NORMAL), + mQueriedProgressSink(true), + mSynthProgressEvents(false), + mAllowThreadRetargeting(true), + mWaitingOnAsyncRedirect(false), + mOpenRedirectChannel(false), + mRedirectFlags{0}, + mStatus(NS_OK), + mContentDispositionHint(UINT32_MAX), + mContentLength(-1), + mWasOpened(false), + mCanceled(false) { + mContentType.AssignLiteral(UNKNOWN_CONTENT_TYPE); +} + +nsBaseChannel::~nsBaseChannel() { + NS_ReleaseOnMainThread("nsBaseChannel::mLoadInfo", mLoadInfo.forget()); +} + +nsresult nsBaseChannel::Redirect(nsIChannel* newChannel, uint32_t redirectFlags, + bool openNewChannel) { + SUSPEND_PUMP_FOR_SCOPE(); + + // Transfer properties + + newChannel->SetLoadGroup(mLoadGroup); + newChannel->SetNotificationCallbacks(mCallbacks); + newChannel->SetLoadFlags(mLoadFlags | LOAD_REPLACE); + + // make a copy of the loadinfo, append to the redirectchain + // and set it on the new channel + nsSecurityFlags secFlags = + mLoadInfo->GetSecurityFlags() & ~nsILoadInfo::SEC_FORCE_INHERIT_PRINCIPAL; + nsCOMPtr<nsILoadInfo> newLoadInfo = + static_cast<net::LoadInfo*>(mLoadInfo.get()) + ->CloneWithNewSecFlags(secFlags); + + nsCOMPtr<nsIPrincipal> uriPrincipal; + nsIScriptSecurityManager* sm = nsContentUtils::GetSecurityManager(); + sm->GetChannelURIPrincipal(this, getter_AddRefs(uriPrincipal)); + bool isInternalRedirect = + (redirectFlags & (nsIChannelEventSink::REDIRECT_INTERNAL | + nsIChannelEventSink::REDIRECT_STS_UPGRADE)); + + // nsBaseChannel hst no thing to do with HttpBaseChannel, we would not care + // about referrer and remote address in this case + nsCOMPtr<nsIRedirectHistoryEntry> entry = + new net::nsRedirectHistoryEntry(uriPrincipal, nullptr, ""_ns); + + newLoadInfo->AppendRedirectHistoryEntry(entry, isInternalRedirect); + + // Ensure the channel's loadInfo's result principal URI so that it's + // either non-null or updated to the redirect target URI. + // We must do this because in case the loadInfo's result principal URI + // is null, it would be taken from OriginalURI of the channel. But we + // overwrite it with the whole redirect chain first URI before opening + // the target channel, hence the information would be lost. + // If the protocol handler that created the channel wants to use + // the originalURI of the channel as the principal URI, it has left + // the result principal URI on the load info null. + nsCOMPtr<nsIURI> resultPrincipalURI; + + nsCOMPtr<nsILoadInfo> existingLoadInfo = newChannel->LoadInfo(); + if (existingLoadInfo) { + existingLoadInfo->GetResultPrincipalURI(getter_AddRefs(resultPrincipalURI)); + } + if (!resultPrincipalURI) { + newChannel->GetOriginalURI(getter_AddRefs(resultPrincipalURI)); + } + + newLoadInfo->SetResultPrincipalURI(resultPrincipalURI); + + newChannel->SetLoadInfo(newLoadInfo); + + // Preserve the privacy bit if it has been overridden + if (mPrivateBrowsingOverriden) { + nsCOMPtr<nsIPrivateBrowsingChannel> newPBChannel = + do_QueryInterface(newChannel); + if (newPBChannel) { + newPBChannel->SetPrivate(mPrivateBrowsing); + } + } + + if (nsCOMPtr<nsIWritablePropertyBag> bag = ::do_QueryInterface(newChannel)) { + nsHashPropertyBag::CopyFrom(bag, static_cast<nsIPropertyBag2*>(this)); + } + + // Notify consumer, giving chance to cancel redirect. + + auto redirectCallbackHelper = MakeRefPtr<net::nsAsyncRedirectVerifyHelper>(); + + bool checkRedirectSynchronously = !openNewChannel; + nsCOMPtr<nsIEventTarget> target = GetNeckoTarget(); + + mRedirectChannel = newChannel; + mRedirectFlags = redirectFlags; + mOpenRedirectChannel = openNewChannel; + nsresult rv = redirectCallbackHelper->Init( + this, newChannel, redirectFlags, target, checkRedirectSynchronously); + if (NS_FAILED(rv)) return rv; + + if (checkRedirectSynchronously && NS_FAILED(mStatus)) return mStatus; + + return NS_OK; +} + +nsresult nsBaseChannel::ContinueRedirect() { + // Make sure to do this _after_ making all the OnChannelRedirect calls + mRedirectChannel->SetOriginalURI(OriginalURI()); + + // If we fail to open the new channel, then we want to leave this channel + // unaffected, so we defer tearing down our channel until we have succeeded + // with the redirect. + + if (mOpenRedirectChannel) { + nsresult rv = NS_OK; + rv = mRedirectChannel->AsyncOpen(mListener); + NS_ENSURE_SUCCESS(rv, rv); + } + + mRedirectChannel = nullptr; + + // close down this channel + Cancel(NS_BINDING_REDIRECTED); + ChannelDone(); + + return NS_OK; +} + +bool nsBaseChannel::HasContentTypeHint() const { + NS_ASSERTION(!Pending(), "HasContentTypeHint called too late"); + return !mContentType.EqualsLiteral(UNKNOWN_CONTENT_TYPE); +} + +nsresult nsBaseChannel::PushStreamConverter(const char* fromType, + const char* toType, + bool invalidatesContentLength, + nsIStreamListener** result) { + NS_ASSERTION(mListener, "no listener"); + + nsresult rv; + nsCOMPtr<nsIStreamConverterService> scs = + do_GetService(NS_STREAMCONVERTERSERVICE_CONTRACTID, &rv); + if (NS_FAILED(rv)) return rv; + + nsCOMPtr<nsIStreamListener> converter; + rv = scs->AsyncConvertData(fromType, toType, mListener, nullptr, + getter_AddRefs(converter)); + if (NS_SUCCEEDED(rv)) { + mListener = converter; + if (invalidatesContentLength) mContentLength = -1; + if (result) { + *result = nullptr; + converter.swap(*result); + } + } + return rv; +} + +nsresult nsBaseChannel::BeginPumpingData() { + nsresult rv; + + rv = BeginAsyncRead(this, getter_AddRefs(mRequest)); + if (NS_SUCCEEDED(rv)) { + mPumpingData = true; + return NS_OK; + } + if (rv != NS_ERROR_NOT_IMPLEMENTED) { + return rv; + } + + nsCOMPtr<nsIInputStream> stream; + nsCOMPtr<nsIChannel> channel; + rv = OpenContentStream(true, getter_AddRefs(stream), getter_AddRefs(channel)); + if (NS_FAILED(rv)) return rv; + + NS_ASSERTION(!stream || !channel, "Got both a channel and a stream?"); + + if (channel) { + nsCOMPtr<nsIRunnable> runnable = new RedirectRunnable(this, channel); + rv = Dispatch(runnable.forget()); + if (NS_SUCCEEDED(rv)) mWaitingOnAsyncRedirect = true; + return rv; + } + + // By assigning mPump, we flag this channel as pending (see Pending). It's + // important that the pending flag is set when we call into the stream (the + // call to AsyncRead results in the stream's AsyncWait method being called) + // and especially when we call into the loadgroup. Our caller takes care to + // release mPump if we return an error. + + nsCOMPtr<nsIEventTarget> target = GetNeckoTarget(); + rv = nsInputStreamPump::Create(getter_AddRefs(mPump), stream, 0, 0, true, + target); + if (NS_FAILED(rv)) { + return rv; + } + + mPumpingData = true; + mRequest = mPump; + rv = mPump->AsyncRead(this); + if (NS_FAILED(rv)) { + return rv; + } + + RefPtr<BlockingPromise> promise; + rv = ListenerBlockingPromise(getter_AddRefs(promise)); + if (NS_FAILED(rv)) { + return rv; + } + + if (promise) { + mPump->Suspend(); + + RefPtr<nsBaseChannel> self(this); + nsCOMPtr<nsISerialEventTarget> serialTarget(do_QueryInterface(target)); + MOZ_ASSERT(serialTarget); + + promise->Then( + serialTarget, __func__, + [self, this](nsresult rv) { + MOZ_ASSERT(mPump); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + mPump->Resume(); + }, + [self, this](nsresult rv) { + MOZ_ASSERT(mPump); + MOZ_ASSERT(NS_FAILED(rv)); + Cancel(rv); + mPump->Resume(); + }); + } + + return NS_OK; +} + +void nsBaseChannel::HandleAsyncRedirect(nsIChannel* newChannel) { + NS_ASSERTION(!mPumpingData, "Shouldn't have gotten here"); + + nsresult rv = mStatus; + if (NS_SUCCEEDED(mStatus)) { + rv = Redirect(newChannel, nsIChannelEventSink::REDIRECT_TEMPORARY, true); + if (NS_SUCCEEDED(rv)) { + // OnRedirectVerifyCallback will be called asynchronously + return; + } + } + + ContinueHandleAsyncRedirect(rv); +} + +void nsBaseChannel::ContinueHandleAsyncRedirect(nsresult result) { + mWaitingOnAsyncRedirect = false; + + if (NS_FAILED(result)) Cancel(result); + + if (NS_FAILED(result) && mListener) { + // Notify our consumer ourselves + mListener->OnStartRequest(this); + mListener->OnStopRequest(this, mStatus); + ChannelDone(); + } + + if (mLoadGroup) mLoadGroup->RemoveRequest(this, nullptr, mStatus); + + // Drop notification callbacks to prevent cycles. + mCallbacks = nullptr; + CallbacksChanged(); +} + +void nsBaseChannel::ClassifyURI() { + // For channels created in the child process, delegate to the parent to + // classify URIs. + if (!XRE_IsParentProcess()) { + return; + } + + if (NS_ShouldClassifyChannel(this)) { + auto classifier = MakeRefPtr<net::nsChannelClassifier>(this); + if (classifier) { + classifier->Start(); + } else { + Cancel(NS_ERROR_OUT_OF_MEMORY); + } + } +} + +//----------------------------------------------------------------------------- +// nsBaseChannel::nsISupports + +NS_IMPL_ADDREF(nsBaseChannel) +NS_IMPL_RELEASE(nsBaseChannel) + +NS_INTERFACE_MAP_BEGIN(nsBaseChannel) + NS_INTERFACE_MAP_ENTRY(nsIRequest) + NS_INTERFACE_MAP_ENTRY(nsIChannel) + NS_INTERFACE_MAP_ENTRY(nsIThreadRetargetableRequest) + NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor) + NS_INTERFACE_MAP_ENTRY(nsITransportEventSink) + NS_INTERFACE_MAP_ENTRY(nsIRequestObserver) + NS_INTERFACE_MAP_ENTRY(nsIStreamListener) + NS_INTERFACE_MAP_ENTRY(nsIThreadRetargetableStreamListener) + NS_INTERFACE_MAP_ENTRY(nsIAsyncVerifyRedirectCallback) + NS_INTERFACE_MAP_ENTRY(nsIPrivateBrowsingChannel) +NS_INTERFACE_MAP_END_INHERITING(nsHashPropertyBag) + +//----------------------------------------------------------------------------- +// nsBaseChannel::nsIRequest + +NS_IMETHODIMP +nsBaseChannel::GetName(nsACString& result) { + if (!mURI) { + result.Truncate(); + return NS_OK; + } + return mURI->GetSpec(result); +} + +NS_IMETHODIMP +nsBaseChannel::IsPending(bool* result) { + *result = Pending(); + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::GetStatus(nsresult* status) { + if (mRequest && NS_SUCCEEDED(mStatus)) { + mRequest->GetStatus(status); + } else { + *status = mStatus; + } + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::Cancel(nsresult status) { + // Ignore redundant cancelation + if (mCanceled) { + return NS_OK; + } + + mCanceled = true; + mStatus = status; + + if (mRequest) { + mRequest->Cancel(status); + } + + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::Suspend() { + NS_ENSURE_TRUE(mPumpingData, NS_ERROR_NOT_INITIALIZED); + NS_ENSURE_TRUE(mRequest, NS_ERROR_NOT_IMPLEMENTED); + return mRequest->Suspend(); +} + +NS_IMETHODIMP +nsBaseChannel::Resume() { + NS_ENSURE_TRUE(mPumpingData, NS_ERROR_NOT_INITIALIZED); + NS_ENSURE_TRUE(mRequest, NS_ERROR_NOT_IMPLEMENTED); + return mRequest->Resume(); +} + +NS_IMETHODIMP +nsBaseChannel::GetLoadFlags(nsLoadFlags* aLoadFlags) { + *aLoadFlags = mLoadFlags; + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::SetLoadFlags(nsLoadFlags aLoadFlags) { + mLoadFlags = aLoadFlags; + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::GetTRRMode(nsIRequest::TRRMode* aTRRMode) { + return GetTRRModeImpl(aTRRMode); +} + +NS_IMETHODIMP +nsBaseChannel::SetTRRMode(nsIRequest::TRRMode aTRRMode) { + return SetTRRModeImpl(aTRRMode); +} + +NS_IMETHODIMP +nsBaseChannel::GetLoadGroup(nsILoadGroup** aLoadGroup) { + nsCOMPtr<nsILoadGroup> loadGroup(mLoadGroup); + loadGroup.forget(aLoadGroup); + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::SetLoadGroup(nsILoadGroup* aLoadGroup) { + if (!CanSetLoadGroup(aLoadGroup)) { + return NS_ERROR_FAILURE; + } + + mLoadGroup = aLoadGroup; + CallbacksChanged(); + UpdatePrivateBrowsing(); + return NS_OK; +} + +//----------------------------------------------------------------------------- +// nsBaseChannel::nsIChannel + +NS_IMETHODIMP +nsBaseChannel::GetOriginalURI(nsIURI** aURI) { + RefPtr<nsIURI> uri = OriginalURI(); + uri.forget(aURI); + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::SetOriginalURI(nsIURI* aURI) { + NS_ENSURE_ARG_POINTER(aURI); + mOriginalURI = aURI; + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::GetURI(nsIURI** aURI) { + nsCOMPtr<nsIURI> uri(mURI); + uri.forget(aURI); + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::GetOwner(nsISupports** aOwner) { + nsCOMPtr<nsISupports> owner(mOwner); + owner.forget(aOwner); + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::SetOwner(nsISupports* aOwner) { + mOwner = aOwner; + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::SetLoadInfo(nsILoadInfo* aLoadInfo) { + MOZ_RELEASE_ASSERT(aLoadInfo, "loadinfo can't be null"); + mLoadInfo = aLoadInfo; + + // Need to update |mNeckoTarget| when load info has changed. + SetupNeckoTarget(); + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::GetLoadInfo(nsILoadInfo** aLoadInfo) { + nsCOMPtr<nsILoadInfo> loadInfo(mLoadInfo); + loadInfo.forget(aLoadInfo); + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::GetIsDocument(bool* aIsDocument) { + return NS_GetIsDocumentChannel(this, aIsDocument); +} + +NS_IMETHODIMP +nsBaseChannel::GetNotificationCallbacks(nsIInterfaceRequestor** aCallbacks) { + nsCOMPtr<nsIInterfaceRequestor> callbacks(mCallbacks); + callbacks.forget(aCallbacks); + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::SetNotificationCallbacks(nsIInterfaceRequestor* aCallbacks) { + if (!CanSetCallbacks(aCallbacks)) { + return NS_ERROR_FAILURE; + } + + mCallbacks = aCallbacks; + CallbacksChanged(); + UpdatePrivateBrowsing(); + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::GetSecurityInfo(nsISupports** aSecurityInfo) { + nsCOMPtr<nsISupports> securityInfo(mSecurityInfo); + securityInfo.forget(aSecurityInfo); + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::GetContentType(nsACString& aContentType) { + aContentType = mContentType; + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::SetContentType(const nsACString& aContentType) { + // mContentCharset is unchanged if not parsed + bool dummy; + net_ParseContentType(aContentType, mContentType, mContentCharset, &dummy); + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::GetContentCharset(nsACString& aContentCharset) { + aContentCharset = mContentCharset; + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::SetContentCharset(const nsACString& aContentCharset) { + mContentCharset = aContentCharset; + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::GetContentDisposition(uint32_t* aContentDisposition) { + // preserve old behavior, fail unless explicitly set. + if (mContentDispositionHint == UINT32_MAX) { + return NS_ERROR_NOT_AVAILABLE; + } + + *aContentDisposition = mContentDispositionHint; + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::SetContentDisposition(uint32_t aContentDisposition) { + mContentDispositionHint = aContentDisposition; + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::GetContentDispositionFilename( + nsAString& aContentDispositionFilename) { + if (!mContentDispositionFilename) { + return NS_ERROR_NOT_AVAILABLE; + } + + aContentDispositionFilename = *mContentDispositionFilename; + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::SetContentDispositionFilename( + const nsAString& aContentDispositionFilename) { + mContentDispositionFilename = + MakeUnique<nsString>(aContentDispositionFilename); + + // For safety reasons ensure the filename doesn't contain null characters and + // replace them with underscores. We may later pass the extension to system + // MIME APIs that expect null terminated strings. + mContentDispositionFilename->ReplaceChar(char16_t(0), '_'); + + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::GetContentDispositionHeader( + nsACString& aContentDispositionHeader) { + return NS_ERROR_NOT_AVAILABLE; +} + +NS_IMETHODIMP +nsBaseChannel::GetContentLength(int64_t* aContentLength) { + *aContentLength = mContentLength; + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::SetContentLength(int64_t aContentLength) { + mContentLength = aContentLength; + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::Open(nsIInputStream** aStream) { + nsCOMPtr<nsIStreamListener> listener; + nsresult rv = + nsContentSecurityManager::doContentSecurityCheck(this, listener); + NS_ENSURE_SUCCESS(rv, rv); + + NS_ENSURE_TRUE(mURI, NS_ERROR_NOT_INITIALIZED); + NS_ENSURE_TRUE(!mPumpingData, NS_ERROR_IN_PROGRESS); + NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_IN_PROGRESS); + + nsCOMPtr<nsIChannel> chan; + rv = OpenContentStream(false, aStream, getter_AddRefs(chan)); + NS_ASSERTION(!chan || !*aStream, "Got both a channel and a stream?"); + if (NS_SUCCEEDED(rv) && chan) { + rv = Redirect(chan, nsIChannelEventSink::REDIRECT_INTERNAL, false); + if (NS_FAILED(rv)) return rv; + rv = chan->Open(aStream); + } else if (rv == NS_ERROR_NOT_IMPLEMENTED) + return NS_ImplementChannelOpen(this, aStream); + + if (NS_SUCCEEDED(rv)) { + mWasOpened = true; + ClassifyURI(); + } + + return rv; +} + +NS_IMETHODIMP +nsBaseChannel::AsyncOpen(nsIStreamListener* aListener) { + nsCOMPtr<nsIStreamListener> listener = aListener; + + nsresult rv = + nsContentSecurityManager::doContentSecurityCheck(this, listener); + if (NS_FAILED(rv)) { + mCallbacks = nullptr; + return rv; + } + + MOZ_ASSERT( + mLoadInfo->GetSecurityMode() == 0 || + mLoadInfo->GetInitialSecurityCheckDone() || + (mLoadInfo->GetSecurityMode() == + nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL && + mLoadInfo->GetLoadingPrincipal() && + mLoadInfo->GetLoadingPrincipal()->IsSystemPrincipal()), + "security flags in loadInfo but doContentSecurityCheck() not called"); + + NS_ENSURE_TRUE(mURI, NS_ERROR_NOT_INITIALIZED); + NS_ENSURE_TRUE(!mPumpingData, NS_ERROR_IN_PROGRESS); + NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_ALREADY_OPENED); + NS_ENSURE_ARG(listener); + + SetupNeckoTarget(); + + // Skip checking for chrome:// sub-resources. + nsAutoCString scheme; + mURI->GetScheme(scheme); + if (!scheme.EqualsLiteral("file")) { + NS_CompareLoadInfoAndLoadContext(this); + } + + // Ensure that this is an allowed port before proceeding. + rv = NS_CheckPortSafety(mURI); + if (NS_FAILED(rv)) { + mCallbacks = nullptr; + return rv; + } + + AntiTrackingUtils::UpdateAntiTrackingInfoForChannel(this); + + // Store the listener and context early so that OpenContentStream and the + // stream's AsyncWait method (called by AsyncRead) can have access to them + // via PushStreamConverter and the StreamListener methods. However, since + // this typically introduces a reference cycle between this and the listener, + // we need to be sure to break the reference if this method does not succeed. + mListener = listener; + + // This method assigns mPump as a side-effect. We need to clear mPump if + // this method fails. + rv = BeginPumpingData(); + if (NS_FAILED(rv)) { + mPump = nullptr; + mRequest = nullptr; + mPumpingData = false; + ChannelDone(); + mCallbacks = nullptr; + return rv; + } + + // At this point, we are going to return success no matter what. + + mWasOpened = true; + + SUSPEND_PUMP_FOR_SCOPE(); + + if (mLoadGroup) mLoadGroup->AddRequest(this, nullptr); + + ClassifyURI(); + + return NS_OK; +} + +//----------------------------------------------------------------------------- +// nsBaseChannel::nsITransportEventSink + +NS_IMETHODIMP +nsBaseChannel::OnTransportStatus(nsITransport* transport, nsresult status, + int64_t progress, int64_t progressMax) { + // In some cases, we may wish to suppress transport-layer status events. + + if (!mPumpingData || NS_FAILED(mStatus)) { + return NS_OK; + } + + SUSPEND_PUMP_FOR_SCOPE(); + + // Lazily fetch mProgressSink + if (!mProgressSink) { + if (mQueriedProgressSink) { + return NS_OK; + } + GetCallback(mProgressSink); + mQueriedProgressSink = true; + if (!mProgressSink) { + return NS_OK; + } + } + + if (!HasLoadFlag(LOAD_BACKGROUND)) { + nsAutoString statusArg; + if (GetStatusArg(status, statusArg)) { + mProgressSink->OnStatus(this, status, statusArg.get()); + } + } + + if (progress) { + mProgressSink->OnProgress(this, progress, progressMax); + } + + return NS_OK; +} + +//----------------------------------------------------------------------------- +// nsBaseChannel::nsIInterfaceRequestor + +NS_IMETHODIMP +nsBaseChannel::GetInterface(const nsIID& iid, void** result) { + NS_QueryNotificationCallbacks(mCallbacks, mLoadGroup, iid, result); + return *result ? NS_OK : NS_ERROR_NO_INTERFACE; +} + +//----------------------------------------------------------------------------- +// nsBaseChannel::nsIRequestObserver + +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); + } +} + +static void CallUnknownTypeSniffer(void* aClosure, const uint8_t* aData, + uint32_t aCount) { + nsIChannel* chan = static_cast<nsIChannel*>(aClosure); + + RefPtr<nsUnknownDecoder> sniffer = new nsUnknownDecoder(); + + nsAutoCString detected; + nsresult rv = sniffer->GetMIMETypeFromContent(chan, aData, aCount, detected); + if (NS_SUCCEEDED(rv)) chan->SetContentType(detected); +} + +NS_IMETHODIMP +nsBaseChannel::OnStartRequest(nsIRequest* request) { + MOZ_ASSERT_IF(mRequest, request == mRequest); + + nsAutoCString scheme; + mURI->GetScheme(scheme); + + if (mPump && !scheme.EqualsLiteral("ftp")) { + // If our content type is unknown, use the content type + // sniffer. If the sniffer is not available for some reason, then we just + // keep going as-is. + if (NS_SUCCEEDED(mStatus) && + mContentType.EqualsLiteral(UNKNOWN_CONTENT_TYPE)) { + mPump->PeekStream(CallUnknownTypeSniffer, static_cast<nsIChannel*>(this)); + } + + // Now, the general type sniffers. Skip this if we have none. + if (mLoadFlags & LOAD_CALL_CONTENT_SNIFFERS) + mPump->PeekStream(CallTypeSniffers, static_cast<nsIChannel*>(this)); + } + + SUSPEND_PUMP_FOR_SCOPE(); + + if (mListener) // null in case of redirect + return mListener->OnStartRequest(this); + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::OnStopRequest(nsIRequest* request, nsresult status) { + // If both mStatus and status are failure codes, we keep mStatus as-is since + // that is consistent with our GetStatus and Cancel methods. + if (NS_SUCCEEDED(mStatus)) mStatus = status; + + // Cause Pending to return false. + mPump = nullptr; + mRequest = nullptr; + mPumpingData = false; + + if (mListener) // null in case of redirect + mListener->OnStopRequest(this, mStatus); + ChannelDone(); + + // No need to suspend pump in this scope since we will not be receiving + // any more events from it. + + if (mLoadGroup) mLoadGroup->RemoveRequest(this, nullptr, mStatus); + + // Drop notification callbacks to prevent cycles. + mCallbacks = nullptr; + CallbacksChanged(); + + return NS_OK; +} + +//----------------------------------------------------------------------------- +// nsBaseChannel::nsIStreamListener + +NS_IMETHODIMP +nsBaseChannel::OnDataAvailable(nsIRequest* request, nsIInputStream* stream, + uint64_t offset, uint32_t count) { + SUSPEND_PUMP_FOR_SCOPE(); + + nsresult rv = mListener->OnDataAvailable(this, stream, offset, count); + if (mSynthProgressEvents && NS_SUCCEEDED(rv)) { + int64_t prog = offset + count; + if (NS_IsMainThread()) { + OnTransportStatus(nullptr, NS_NET_STATUS_READING, prog, mContentLength); + } else { + class OnTransportStatusAsyncEvent : public Runnable { + RefPtr<nsBaseChannel> mChannel; + int64_t mProgress; + int64_t mContentLength; + + public: + OnTransportStatusAsyncEvent(nsBaseChannel* aChannel, int64_t aProgress, + int64_t aContentLength) + : Runnable("OnTransportStatusAsyncEvent"), + mChannel(aChannel), + mProgress(aProgress), + mContentLength(aContentLength) {} + + NS_IMETHOD Run() override { + return mChannel->OnTransportStatus(nullptr, NS_NET_STATUS_READING, + mProgress, mContentLength); + } + }; + + nsCOMPtr<nsIRunnable> runnable = + new OnTransportStatusAsyncEvent(this, prog, mContentLength); + Dispatch(runnable.forget()); + } + } + + return rv; +} + +NS_IMETHODIMP +nsBaseChannel::OnRedirectVerifyCallback(nsresult result) { + if (NS_SUCCEEDED(result)) result = ContinueRedirect(); + + if (NS_FAILED(result) && !mWaitingOnAsyncRedirect) { + if (NS_SUCCEEDED(mStatus)) mStatus = result; + return NS_OK; + } + + if (mWaitingOnAsyncRedirect) ContinueHandleAsyncRedirect(result); + + return NS_OK; +} + +NS_IMETHODIMP +nsBaseChannel::RetargetDeliveryTo(nsIEventTarget* aEventTarget) { + MOZ_ASSERT(NS_IsMainThread()); + + NS_ENSURE_TRUE(mRequest, NS_ERROR_NOT_INITIALIZED); + + nsCOMPtr<nsIThreadRetargetableRequest> req; + if (mAllowThreadRetargeting) { + req = do_QueryInterface(mRequest); + } + + NS_ENSURE_TRUE(req, NS_ERROR_NOT_IMPLEMENTED); + + return req->RetargetDeliveryTo(aEventTarget); +} + +NS_IMETHODIMP +nsBaseChannel::GetDeliveryTarget(nsIEventTarget** aEventTarget) { + MOZ_ASSERT(NS_IsMainThread()); + + NS_ENSURE_TRUE(mRequest, NS_ERROR_NOT_INITIALIZED); + + nsCOMPtr<nsIThreadRetargetableRequest> req; + req = do_QueryInterface(mRequest); + + NS_ENSURE_TRUE(req, NS_ERROR_NOT_IMPLEMENTED); + return req->GetDeliveryTarget(aEventTarget); +} + +NS_IMETHODIMP +nsBaseChannel::CheckListenerChain() { + MOZ_ASSERT(NS_IsMainThread()); + + if (!mAllowThreadRetargeting) { + return NS_ERROR_NOT_IMPLEMENTED; + } + + nsCOMPtr<nsIThreadRetargetableStreamListener> listener = + do_QueryInterface(mListener); + if (!listener) { + return NS_ERROR_NO_INTERFACE; + } + + return listener->CheckListenerChain(); +} + +NS_IMETHODIMP nsBaseChannel::GetCanceled(bool* aCanceled) { + *aCanceled = mCanceled; + return NS_OK; +} + +void nsBaseChannel::SetupNeckoTarget() { + mNeckoTarget = + nsContentUtils::GetEventTargetByLoadInfo(mLoadInfo, TaskCategory::Other); +} diff --git a/netwerk/base/nsBaseChannel.h b/netwerk/base/nsBaseChannel.h new file mode 100644 index 0000000000..c6e12d9b33 --- /dev/null +++ b/netwerk/base/nsBaseChannel.h @@ -0,0 +1,306 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef nsBaseChannel_h__ +#define nsBaseChannel_h__ + +#include "mozilla/net/NeckoTargetHolder.h" +#include "mozilla/Maybe.h" +#include "mozilla/MozPromise.h" +#include "mozilla/UniquePtr.h" +#include "nsString.h" +#include "nsCOMPtr.h" +#include "nsHashPropertyBag.h" +#include "nsInputStreamPump.h" + +#include "nsIChannel.h" +#include "nsIURI.h" +#include "nsILoadGroup.h" +#include "nsILoadInfo.h" +#include "nsIStreamListener.h" +#include "nsIInterfaceRequestor.h" +#include "nsIProgressEventSink.h" +#include "nsITransport.h" +#include "nsIAsyncVerifyRedirectCallback.h" +#include "nsIThreadRetargetableRequest.h" +#include "nsIThreadRetargetableStreamListener.h" +#include "mozilla/net/PrivateBrowsingChannel.h" +#include "nsThreadUtils.h" + +class nsIInputStream; + +//----------------------------------------------------------------------------- +// nsBaseChannel is designed to be subclassed. The subclass is responsible for +// implementing the OpenContentStream method, which will be called by the +// nsIChannel::AsyncOpen and nsIChannel::Open implementations. +// +// nsBaseChannel implements nsIInterfaceRequestor to provide a convenient way +// for subclasses to query both the nsIChannel::notificationCallbacks and +// nsILoadGroup::notificationCallbacks for supported interfaces. +// +// nsBaseChannel implements nsITransportEventSink to support progress & status +// notifications generated by the transport layer. + +class nsBaseChannel + : public nsHashPropertyBag, + public nsIChannel, + public nsIThreadRetargetableRequest, + public nsIInterfaceRequestor, + public nsITransportEventSink, + public nsIAsyncVerifyRedirectCallback, + public mozilla::net::PrivateBrowsingChannel<nsBaseChannel>, + public mozilla::net::NeckoTargetHolder, + protected nsIStreamListener, + protected nsIThreadRetargetableStreamListener { + public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_NSIREQUEST + NS_DECL_NSICHANNEL + NS_DECL_NSIINTERFACEREQUESTOR + NS_DECL_NSITRANSPORTEVENTSINK + NS_DECL_NSIASYNCVERIFYREDIRECTCALLBACK + NS_DECL_NSITHREADRETARGETABLEREQUEST + NS_DECL_NSITHREADRETARGETABLESTREAMLISTENER + + nsBaseChannel(); + + protected: + // ----------------------------------------------- + // Methods to be implemented by the derived class: + + virtual ~nsBaseChannel(); + + using BlockingPromise = mozilla::MozPromise<nsresult, nsresult, true>; + + private: + // Implemented by subclass to supply data stream. The parameter, async, is + // true when called from nsIChannel::AsyncOpen and false otherwise. When + // async is true, the resulting stream will be used with a nsIInputStreamPump + // instance. This means that if it is a non-blocking stream that supports + // nsIAsyncInputStream that it will be read entirely on the main application + // thread, and its AsyncWait method will be called whenever ReadSegments + // returns NS_BASE_STREAM_WOULD_BLOCK. Otherwise, if the stream is blocking, + // then it will be read on one of the background I/O threads, and it does not + // need to implement ReadSegments. If async is false, this method may return + // NS_ERROR_NOT_IMPLEMENTED to cause the basechannel to implement Open in + // terms of AsyncOpen (see NS_ImplementChannelOpen). + // A callee is allowed to return an nsIChannel instead of an nsIInputStream. + // That case will be treated as a redirect to the new channel. By default + // *channel will be set to null by the caller, so callees who don't want to + // return one an just not touch it. + virtual nsresult OpenContentStream(bool async, nsIInputStream** stream, + nsIChannel** channel) = 0; + + // Implemented by subclass to begin pumping data for an async channel, in + // lieu of returning a stream. If implemented, OpenContentStream will never + // be called for async channels. If not implemented, AsyncOpen will fall + // back to OpenContentStream. + // + // On success, the callee must begin pumping data to the stream listener, + // and at some point call OnStartRequest followed by OnStopRequest. + // Additionally, it may provide a request object which may be used to + // suspend, resume, and cancel the underlying request. + virtual nsresult BeginAsyncRead(nsIStreamListener* listener, + nsIRequest** request) { + return NS_ERROR_NOT_IMPLEMENTED; + } + + // This method may return a promise that will keep the input stream pump + // suspended until the promise is resolved or rejected. On resolution the + // pump is resumed. On rejection the channel is canceled with the resulting + // error and then the pump is also resumed to propagate the error to the + // channel listener. Use it to do any asynchronous/background tasks you need + // to finish prior calling OnStartRequest of the listener. This method is + // called right after OpenContentStream() with async == true, after the input + // stream pump has already been called asyncRead(). + virtual nsresult ListenerBlockingPromise(BlockingPromise** aPromise) { + NS_ENSURE_ARG(aPromise); + *aPromise = nullptr; + return NS_OK; + } + + // The basechannel calls this method from its OnTransportStatus method to + // determine whether to call nsIProgressEventSink::OnStatus in addition to + // nsIProgressEventSink::OnProgress. This method may be overriden by the + // subclass to enable nsIProgressEventSink::OnStatus events. If this method + // returns true, then the statusArg out param specifies the "statusArg" value + // to pass to the OnStatus method. By default, OnStatus messages are + // suppressed. The status parameter passed to this method is the status value + // from the OnTransportStatus method. + virtual bool GetStatusArg(nsresult status, nsString& statusArg) { + return false; + } + + // Called when the callbacks available to this channel may have changed. + virtual void OnCallbacksChanged() {} + + // Called when our channel is done, to allow subclasses to drop resources. + virtual void OnChannelDone() {} + + public: + // ---------------------------------------------- + // Methods provided for use by the derived class: + + // Redirect to another channel. This method takes care of notifying + // observers of this redirect as well as of opening the new channel, if asked + // to do so. It also cancels |this| with the status code + // NS_BINDING_REDIRECTED. A failure return from this method means that the + // redirect could not be performed (no channel was opened; this channel + // wasn't canceled.) The redirectFlags parameter consists of the flag values + // defined on nsIChannelEventSink. + nsresult Redirect(nsIChannel* newChannel, uint32_t redirectFlags, + bool openNewChannel); + + // Tests whether a type hint was set. Subclasses can use this to decide + // whether to call SetContentType. + // NOTE: This is only reliable if the subclass didn't itself call + // SetContentType, and should also not be called after OpenContentStream. + bool HasContentTypeHint() const; + + // The URI member should be initialized before the channel is used, and then + // it should never be changed again until the channel is destroyed. + nsIURI* URI() { return mURI; } + void SetURI(nsIURI* uri) { + NS_ASSERTION(uri, "must specify a non-null URI"); + NS_ASSERTION(!mURI, "must not modify URI"); + NS_ASSERTION(!mOriginalURI, "how did that get set so early?"); + mURI = uri; + mOriginalURI = uri; + } + nsIURI* OriginalURI() { return mOriginalURI; } + + // The security info is a property of the transport-layer, which should be + // assigned by the subclass. + nsISupports* SecurityInfo() { return mSecurityInfo; } + void SetSecurityInfo(nsISupports* info) { mSecurityInfo = info; } + + // Test the load flags + bool HasLoadFlag(uint32_t flag) { return (mLoadFlags & flag) != 0; } + + // This is a short-cut to calling nsIRequest::IsPending() + virtual bool Pending() const { + return mPumpingData || mWaitingOnAsyncRedirect; + } + + // Helper function for querying the channel's notification callbacks. + template <class T> + void GetCallback(nsCOMPtr<T>& result) { + GetInterface(NS_GET_TEMPLATE_IID(T), getter_AddRefs(result)); + } + + // If a subclass does not want to feed transport-layer progress events to the + // base channel via nsITransportEventSink, then it may set this flag to cause + // the base channel to synthesize progress events when it receives data from + // the content stream. By default, progress events are not synthesized. + void EnableSynthesizedProgressEvents(bool enable) { + mSynthProgressEvents = enable; + } + + // Some subclasses may wish to manually insert a stream listener between this + // and the channel's listener. The following methods make that possible. + void SetStreamListener(nsIStreamListener* listener) { mListener = listener; } + nsIStreamListener* StreamListener() { return mListener; } + + // Pushes a new stream converter in front of the channel's stream listener. + // The fromType and toType values are passed to nsIStreamConverterService's + // AsyncConvertData method. If invalidatesContentLength is true, then the + // channel's content-length property will be assigned a value of -1. This is + // necessary when the converter changes the length of the resulting data + // stream, which is almost always the case for a "stream converter" ;-) + // This function optionally returns a reference to the new converter. + nsresult PushStreamConverter(const char* fromType, const char* toType, + bool invalidatesContentLength = true, + nsIStreamListener** converter = nullptr); + + protected: + void DisallowThreadRetargeting() { mAllowThreadRetargeting = false; } + + virtual void SetupNeckoTarget(); + + private: + NS_DECL_NSISTREAMLISTENER + NS_DECL_NSIREQUESTOBSERVER + + // Called to setup mPump and call AsyncRead on it. + nsresult BeginPumpingData(); + + // Called when the callbacks available to this channel may have changed. + void CallbacksChanged() { + mProgressSink = nullptr; + mQueriedProgressSink = false; + OnCallbacksChanged(); + } + + // Called when our channel is done. This should drop no-longer-needed + // pointers. + void ChannelDone() { + mListener = nullptr; + OnChannelDone(); + } + + // Handle an async redirect callback. This will only be called if we + // returned success from AsyncOpen while posting a redirect runnable. + void HandleAsyncRedirect(nsIChannel* newChannel); + void ContinueHandleAsyncRedirect(nsresult result); + nsresult ContinueRedirect(); + + // start URI classifier if requested + void ClassifyURI(); + + class RedirectRunnable : public mozilla::Runnable { + public: + RedirectRunnable(nsBaseChannel* chan, nsIChannel* newChannel) + : mozilla::Runnable("nsBaseChannel::RedirectRunnable"), + mChannel(chan), + mNewChannel(newChannel) { + MOZ_ASSERT(newChannel, "Must have channel to redirect to"); + } + + NS_IMETHOD Run() override { + mChannel->HandleAsyncRedirect(mNewChannel); + return NS_OK; + } + + private: + RefPtr<nsBaseChannel> mChannel; + nsCOMPtr<nsIChannel> mNewChannel; + }; + friend class RedirectRunnable; + + RefPtr<nsInputStreamPump> mPump; + RefPtr<nsIRequest> mRequest; + bool mPumpingData; + nsCOMPtr<nsIProgressEventSink> mProgressSink; + nsCOMPtr<nsIURI> mOriginalURI; + nsCOMPtr<nsISupports> mOwner; + nsCOMPtr<nsISupports> mSecurityInfo; + nsCOMPtr<nsIChannel> mRedirectChannel; + nsCString mContentType; + nsCString mContentCharset; + uint32_t mLoadFlags; + bool mQueriedProgressSink; + bool mSynthProgressEvents; + bool mAllowThreadRetargeting; + bool mWaitingOnAsyncRedirect; + bool mOpenRedirectChannel; + uint32_t mRedirectFlags; + + protected: + nsCOMPtr<nsIURI> mURI; + nsCOMPtr<nsILoadGroup> mLoadGroup; + nsCOMPtr<nsILoadInfo> mLoadInfo; + nsCOMPtr<nsIInterfaceRequestor> mCallbacks; + nsCOMPtr<nsIStreamListener> mListener; + nsresult mStatus; + uint32_t mContentDispositionHint; + mozilla::UniquePtr<nsString> mContentDispositionFilename; + int64_t mContentLength; + bool mWasOpened; + bool mCanceled; + + friend class mozilla::net::PrivateBrowsingChannel<nsBaseChannel>; +}; + +#endif // !nsBaseChannel_h__ diff --git a/netwerk/base/nsBaseContentStream.cpp b/netwerk/base/nsBaseContentStream.cpp new file mode 100644 index 0000000000..e2d7cfc8d5 --- /dev/null +++ b/netwerk/base/nsBaseContentStream.cpp @@ -0,0 +1,124 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "nsBaseContentStream.h" +#include "nsStreamUtils.h" + +//----------------------------------------------------------------------------- + +void nsBaseContentStream::DispatchCallback(bool async) { + if (!mCallback) return; + + // It's important to clear mCallback and mCallbackTarget up-front because the + // OnInputStreamReady implementation may call our AsyncWait method. + + nsCOMPtr<nsIInputStreamCallback> callback; + if (async) { + callback = NS_NewInputStreamReadyEvent( + "nsBaseContentStream::DispatchCallback", mCallback, mCallbackTarget); + mCallback = nullptr; + } else { + callback.swap(mCallback); + } + mCallbackTarget = nullptr; + + callback->OnInputStreamReady(this); +} + +//----------------------------------------------------------------------------- +// nsBaseContentStream::nsISupports + +NS_IMPL_ADDREF(nsBaseContentStream) +NS_IMPL_RELEASE(nsBaseContentStream) + +// We only support nsIAsyncInputStream when we are in non-blocking mode. +NS_INTERFACE_MAP_BEGIN(nsBaseContentStream) + NS_INTERFACE_MAP_ENTRY(nsIInputStream) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAsyncInputStream, mNonBlocking) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIInputStream) +NS_INTERFACE_MAP_END + +//----------------------------------------------------------------------------- +// nsBaseContentStream::nsIInputStream + +NS_IMETHODIMP +nsBaseContentStream::Close() { + return IsClosed() ? NS_OK : CloseWithStatus(NS_BASE_STREAM_CLOSED); +} + +NS_IMETHODIMP +nsBaseContentStream::Available(uint64_t* result) { + *result = 0; + return mStatus; +} + +NS_IMETHODIMP +nsBaseContentStream::Read(char* buf, uint32_t count, uint32_t* result) { + return ReadSegments(NS_CopySegmentToBuffer, buf, count, result); +} + +NS_IMETHODIMP +nsBaseContentStream::ReadSegments(nsWriteSegmentFun fun, void* closure, + uint32_t count, uint32_t* result) { + *result = 0; + + if (mStatus == NS_BASE_STREAM_CLOSED) return NS_OK; + + // No data yet + if (!IsClosed() && IsNonBlocking()) return NS_BASE_STREAM_WOULD_BLOCK; + + return mStatus; +} + +NS_IMETHODIMP +nsBaseContentStream::IsNonBlocking(bool* result) { + *result = mNonBlocking; + return NS_OK; +} + +//----------------------------------------------------------------------------- +// nsBaseContentStream::nsIAsyncInputStream + +NS_IMETHODIMP +nsBaseContentStream::CloseWithStatus(nsresult status) { + if (IsClosed()) return NS_OK; + + NS_ENSURE_ARG(NS_FAILED(status)); + mStatus = status; + + DispatchCallback(); + return NS_OK; +} + +NS_IMETHODIMP +nsBaseContentStream::AsyncWait(nsIInputStreamCallback* callback, uint32_t flags, + uint32_t requestedCount, + nsIEventTarget* target) { + // Our _only_ consumer is nsInputStreamPump, so we simplify things here by + // making assumptions about how we will be called. + NS_ASSERTION(target, "unexpected parameter"); + NS_ASSERTION(flags == 0, "unexpected parameter"); + NS_ASSERTION(requestedCount == 0, "unexpected parameter"); + +#ifdef DEBUG + bool correctThread; + target->IsOnCurrentThread(&correctThread); + NS_ASSERTION(correctThread, "event target must be on the current thread"); +#endif + + mCallback = callback; + mCallbackTarget = target; + + if (!mCallback) return NS_OK; + + // If we're already closed, then dispatch this callback immediately. + if (IsClosed()) { + DispatchCallback(); + return NS_OK; + } + + OnCallbackPending(); + return NS_OK; +} diff --git a/netwerk/base/nsBaseContentStream.h b/netwerk/base/nsBaseContentStream.h new file mode 100644 index 0000000000..13a3766857 --- /dev/null +++ b/netwerk/base/nsBaseContentStream.h @@ -0,0 +1,79 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef nsBaseContentStream_h__ +#define nsBaseContentStream_h__ + +#include "nsIAsyncInputStream.h" +#include "nsIEventTarget.h" +#include "nsCOMPtr.h" + +//----------------------------------------------------------------------------- +// nsBaseContentStream is designed to be subclassed with the intention of being +// used to satisfy the nsBaseChannel::OpenContentStream method. +// +// The subclass typically overrides the default Available, ReadSegments and +// CloseWithStatus methods. By default, Read is implemented in terms of +// ReadSegments, and Close is implemented in terms of CloseWithStatus. If +// CloseWithStatus is overriden, then the subclass will usually want to call +// the base class' CloseWithStatus method before returning. +// +// If the stream is non-blocking, then readSegments may return the exception +// NS_BASE_STREAM_WOULD_BLOCK if there is no data available and the stream is +// not at the "end-of-file" or already closed. This error code must not be +// returned from the Available implementation. When the caller receives this +// error code, he may choose to call the stream's AsyncWait method, in which +// case the base stream will have a non-null PendingCallback. When the stream +// has data or encounters an error, it should be sure to dispatch a pending +// callback if one exists (see DispatchCallback). The implementation of the +// base stream's CloseWithStatus (and Close) method will ensure that any +// pending callback is dispatched. It is the responsibility of the subclass +// to ensure that the pending callback is dispatched when it wants to have its +// ReadSegments method called again. + +class nsBaseContentStream : public nsIAsyncInputStream { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIINPUTSTREAM + NS_DECL_NSIASYNCINPUTSTREAM + + explicit nsBaseContentStream(bool nonBlocking) + : mStatus(NS_OK), mNonBlocking(nonBlocking) {} + + nsresult Status() { return mStatus; } + bool IsNonBlocking() { return mNonBlocking; } + bool IsClosed() { return NS_FAILED(mStatus); } + + // Called to test if the stream has a pending callback. + bool HasPendingCallback() { return mCallback != nullptr; } + + // The current dispatch target (may be null) for the pending callback if any. + nsIEventTarget* CallbackTarget() { return mCallbackTarget; } + + // Called to dispatch a pending callback. If there is no pending callback, + // then this function does nothing. Pass true to this function to cause the + // callback to occur asynchronously; otherwise, the callback will happen + // before this function returns. + void DispatchCallback(bool async = true); + + // Helper function to make code more self-documenting. + void DispatchCallbackSync() { DispatchCallback(false); } + + protected: + virtual ~nsBaseContentStream() = default; + + private: + // Called from the base stream's AsyncWait method when a pending callback + // is installed on the stream. + virtual void OnCallbackPending() {} + + private: + nsCOMPtr<nsIInputStreamCallback> mCallback; + nsCOMPtr<nsIEventTarget> mCallbackTarget; + nsresult mStatus; + bool mNonBlocking; +}; + +#endif // nsBaseContentStream_h__ diff --git a/netwerk/base/nsBufferedStreams.cpp b/netwerk/base/nsBufferedStreams.cpp new file mode 100644 index 0000000000..b5deb0c854 --- /dev/null +++ b/netwerk/base/nsBufferedStreams.cpp @@ -0,0 +1,1191 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "nsBufferedStreams.h" +#include "nsStreamUtils.h" +#include "nsNetCID.h" +#include "nsIClassInfoImpl.h" +#include "nsIEventTarget.h" +#include "nsThreadUtils.h" +#include "mozilla/DebugOnly.h" +#include "mozilla/ipc/InputStreamUtils.h" +#include <algorithm> + +#ifdef DEBUG_brendan +# define METERING +#endif + +#ifdef METERING +# include <stdio.h> +# define METER(x) x +# define MAX_BIG_SEEKS 20 + +static struct { + uint32_t mSeeksWithinBuffer; + uint32_t mSeeksOutsideBuffer; + uint32_t mBufferReadUponSeek; + uint32_t mBufferUnreadUponSeek; + uint32_t mBytesReadFromBuffer; + uint32_t mBigSeekIndex; + struct { + int64_t mOldOffset; + int64_t mNewOffset; + } mBigSeek[MAX_BIG_SEEKS]; +} bufstats; +#else +# define METER(x) /* nothing */ +#endif + +using namespace mozilla::ipc; +using mozilla::DebugOnly; +using mozilla::Maybe; +using mozilla::MutexAutoLock; +using mozilla::Nothing; +using mozilla::Some; + +//////////////////////////////////////////////////////////////////////////////// +// nsBufferedStream + +nsBufferedStream::nsBufferedStream() + : mBufferSize(0), + mBuffer(nullptr), + mBufferStartOffset(0), + mCursor(0), + mFillPoint(0), + mStream(nullptr), + mBufferDisabled(false), + mEOF(false), + mGetBufferCount(0) {} + +nsBufferedStream::~nsBufferedStream() { Close(); } + +NS_IMPL_ISUPPORTS(nsBufferedStream, nsITellableStream, nsISeekableStream) + +nsresult nsBufferedStream::Init(nsISupports* aStream, uint32_t bufferSize) { + NS_ASSERTION(aStream, "need to supply a stream"); + NS_ASSERTION(mStream == nullptr, "already inited"); + mStream = aStream; // we keep a reference until nsBufferedStream::Close + mBufferSize = bufferSize; + mBufferStartOffset = 0; + mCursor = 0; + mBuffer = new (mozilla::fallible) char[bufferSize]; + if (mBuffer == nullptr) { + return NS_ERROR_OUT_OF_MEMORY; + } + return NS_OK; +} + +void nsBufferedStream::Close() { + // Drop the reference from nsBufferedStream::Init() + mStream = nullptr; + if (mBuffer) { + delete[] mBuffer; + mBuffer = nullptr; + mBufferSize = 0; + mBufferStartOffset = 0; + mCursor = 0; + mFillPoint = 0; + } +#ifdef METERING + { + static FILE* tfp; + if (!tfp) { + tfp = fopen("/tmp/bufstats", "w"); + if (tfp) { + setvbuf(tfp, nullptr, _IOLBF, 0); + } + } + if (tfp) { + fprintf(tfp, "seeks within buffer: %u\n", bufstats.mSeeksWithinBuffer); + fprintf(tfp, "seeks outside buffer: %u\n", + bufstats.mSeeksOutsideBuffer); + fprintf(tfp, "buffer read on seek: %u\n", + bufstats.mBufferReadUponSeek); + fprintf(tfp, "buffer unread on seek: %u\n", + bufstats.mBufferUnreadUponSeek); + fprintf(tfp, "bytes read from buffer: %u\n", + bufstats.mBytesReadFromBuffer); + for (uint32_t i = 0; i < bufstats.mBigSeekIndex; i++) { + fprintf(tfp, "bigseek[%u] = {old: %u, new: %u}\n", i, + bufstats.mBigSeek[i].mOldOffset, + bufstats.mBigSeek[i].mNewOffset); + } + } + } +#endif +} + +NS_IMETHODIMP +nsBufferedStream::Seek(int32_t whence, int64_t offset) { + if (mStream == nullptr) { + return NS_BASE_STREAM_CLOSED; + } + + // If the underlying stream isn't a random access store, then fail early. + // We could possibly succeed for the case where the seek position denotes + // something that happens to be read into the buffer, but that would make + // the failure data-dependent. + nsresult rv; + nsCOMPtr<nsISeekableStream> ras = do_QueryInterface(mStream, &rv); + if (NS_FAILED(rv)) { + NS_WARNING("mStream doesn't QI to nsISeekableStream"); + return rv; + } + + int64_t absPos = 0; + switch (whence) { + case nsISeekableStream::NS_SEEK_SET: + absPos = offset; + break; + case nsISeekableStream::NS_SEEK_CUR: + absPos = mBufferStartOffset; + absPos += mCursor; + absPos += offset; + break; + case nsISeekableStream::NS_SEEK_END: + absPos = -1; + break; + default: + MOZ_ASSERT_UNREACHABLE("bogus seek whence parameter"); + return NS_ERROR_UNEXPECTED; + } + + // Let mCursor point into the existing buffer if the new position is + // between the current cursor and the mFillPoint "fencepost" -- the + // client may never get around to a Read or Write after this Seek. + // Read and Write worry about flushing and filling in that event. + // But if we're at EOF, make sure to pass the seek through to the + // underlying stream, because it may have auto-closed itself and + // needs to reopen. + uint32_t offsetInBuffer = uint32_t(absPos - mBufferStartOffset); + if (offsetInBuffer <= mFillPoint && !mEOF) { + METER(bufstats.mSeeksWithinBuffer++); + mCursor = offsetInBuffer; + return NS_OK; + } + + METER(bufstats.mSeeksOutsideBuffer++); + METER(bufstats.mBufferReadUponSeek += mCursor); + METER(bufstats.mBufferUnreadUponSeek += mFillPoint - mCursor); + rv = Flush(); + if (NS_FAILED(rv)) { +#ifdef DEBUG + NS_WARNING( + "(debug) Flush returned error within nsBufferedStream::Seek, so we " + "exit early."); +#endif + return rv; + } + + rv = ras->Seek(whence, offset); + if (NS_FAILED(rv)) { +#ifdef DEBUG + NS_WARNING( + "(debug) Error: ras->Seek() returned error within " + "nsBufferedStream::Seek, so we exit early."); +#endif + return rv; + } + + mEOF = false; + + // Recompute whether the offset we're seeking to is in our buffer. + // Note that we need to recompute because Flush() might have + // changed mBufferStartOffset. + offsetInBuffer = uint32_t(absPos - mBufferStartOffset); + if (offsetInBuffer <= mFillPoint) { + // It's safe to just set mCursor to offsetInBuffer. In particular, we + // want to avoid calling Fill() here since we already have the data that + // was seeked to and calling Fill() might auto-close our underlying + // stream in some cases. + mCursor = offsetInBuffer; + return NS_OK; + } + + METER(if (bufstats.mBigSeekIndex < MAX_BIG_SEEKS) + bufstats.mBigSeek[bufstats.mBigSeekIndex] + .mOldOffset = mBufferStartOffset + int64_t(mCursor)); + const int64_t minus1 = -1; + if (absPos == minus1) { + // then we had the SEEK_END case, above + int64_t tellPos; + rv = ras->Tell(&tellPos); + mBufferStartOffset = tellPos; + if (NS_FAILED(rv)) { + return rv; + } + } else { + mBufferStartOffset = absPos; + } + METER(if (bufstats.mBigSeekIndex < MAX_BIG_SEEKS) + bufstats.mBigSeek[bufstats.mBigSeekIndex++] + .mNewOffset = mBufferStartOffset); + + mFillPoint = mCursor = 0; + + // If we seeked back to the start, then don't fill the buffer + // right now in case this is a lazily-opened file stream. + // We'll fill on the first read, like we did initially. + if (whence == nsISeekableStream::NS_SEEK_SET && offset == 0) { + return NS_OK; + } + return Fill(); +} + +NS_IMETHODIMP +nsBufferedStream::Tell(int64_t* result) { + if (mStream == nullptr) { + return NS_BASE_STREAM_CLOSED; + } + + int64_t result64 = mBufferStartOffset; + result64 += mCursor; + *result = result64; + return NS_OK; +} + +NS_IMETHODIMP +nsBufferedStream::SetEOF() { + if (mStream == nullptr) { + return NS_BASE_STREAM_CLOSED; + } + + nsresult rv; + nsCOMPtr<nsISeekableStream> ras = do_QueryInterface(mStream, &rv); + if (NS_FAILED(rv)) { + return rv; + } + + rv = ras->SetEOF(); + if (NS_SUCCEEDED(rv)) { + mEOF = true; + } + + return rv; +} + +nsresult nsBufferedStream::GetData(nsISupports** aResult) { + nsCOMPtr<nsISupports> stream(mStream); + stream.forget(aResult); + return NS_OK; +} + +//////////////////////////////////////////////////////////////////////////////// +// nsBufferedInputStream + +NS_IMPL_ADDREF_INHERITED(nsBufferedInputStream, nsBufferedStream) +NS_IMPL_RELEASE_INHERITED(nsBufferedInputStream, nsBufferedStream) + +NS_IMPL_CLASSINFO(nsBufferedInputStream, nullptr, nsIClassInfo::THREADSAFE, + NS_BUFFEREDINPUTSTREAM_CID) + +NS_INTERFACE_MAP_BEGIN(nsBufferedInputStream) + // Unfortunately there isn't a macro that combines ambiguous and conditional, + // and as far as I can tell, no other class would need such a macro. + if (mIsAsyncInputStream && aIID.Equals(NS_GET_IID(nsIInputStream))) { + foundInterface = + static_cast<nsIInputStream*>(static_cast<nsIAsyncInputStream*>(this)); + } else if (!mIsAsyncInputStream && aIID.Equals(NS_GET_IID(nsIInputStream))) { + foundInterface = static_cast<nsIInputStream*>( + static_cast<nsIBufferedInputStream*>(this)); + } else + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIBufferedInputStream) + NS_INTERFACE_MAP_ENTRY(nsIBufferedInputStream) + NS_INTERFACE_MAP_ENTRY(nsIStreamBufferAccess) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIIPCSerializableInputStream, + mIsIPCSerializable) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAsyncInputStream, mIsAsyncInputStream) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIInputStreamCallback, + mIsAsyncInputStream) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsICloneableInputStream, + mIsCloneableInputStream) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIInputStreamLength, mIsInputStreamLength) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAsyncInputStreamLength, + mIsAsyncInputStreamLength) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIInputStreamLengthCallback, + mIsAsyncInputStreamLength) + NS_IMPL_QUERY_CLASSINFO(nsBufferedInputStream) +NS_INTERFACE_MAP_END_INHERITING(nsBufferedStream) + +NS_IMPL_CI_INTERFACE_GETTER(nsBufferedInputStream, nsIInputStream, + nsIBufferedInputStream, nsISeekableStream, + nsITellableStream, nsIStreamBufferAccess) + +nsBufferedInputStream::nsBufferedInputStream() + : nsBufferedStream(), + mMutex("nsBufferedInputStream::mMutex"), + mIsIPCSerializable(true), + mIsAsyncInputStream(false), + mIsCloneableInputStream(false), + mIsInputStreamLength(false), + mIsAsyncInputStreamLength(false) {} + +nsresult nsBufferedInputStream::Create(nsISupports* aOuter, REFNSIID aIID, + void** aResult) { + NS_ENSURE_NO_AGGREGATION(aOuter); + + RefPtr<nsBufferedInputStream> stream = new nsBufferedInputStream(); + return stream->QueryInterface(aIID, aResult); +} + +NS_IMETHODIMP +nsBufferedInputStream::Init(nsIInputStream* stream, uint32_t bufferSize) { + nsresult rv = nsBufferedStream::Init(stream, bufferSize); + NS_ENSURE_SUCCESS(rv, rv); + + { + nsCOMPtr<nsIIPCSerializableInputStream> stream = do_QueryInterface(mStream); + mIsIPCSerializable = !!stream; + } + + { + nsCOMPtr<nsIAsyncInputStream> stream = do_QueryInterface(mStream); + mIsAsyncInputStream = !!stream; + } + + { + nsCOMPtr<nsICloneableInputStream> stream = do_QueryInterface(mStream); + mIsCloneableInputStream = !!stream; + } + + { + nsCOMPtr<nsIInputStreamLength> stream = do_QueryInterface(mStream); + mIsInputStreamLength = !!stream; + } + + { + nsCOMPtr<nsIAsyncInputStreamLength> stream = do_QueryInterface(mStream); + mIsAsyncInputStreamLength = !!stream; + } + + return NS_OK; +} + +already_AddRefed<nsIInputStream> nsBufferedInputStream::GetInputStream() { + // A non-null mStream implies Init() has been called. + MOZ_ASSERT(mStream); + + nsIInputStream* out = nullptr; + DebugOnly<nsresult> rv = QueryInterface(NS_GET_IID(nsIInputStream), + reinterpret_cast<void**>(&out)); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + MOZ_ASSERT(out); + + return already_AddRefed<nsIInputStream>(out); +} + +NS_IMETHODIMP +nsBufferedInputStream::Close() { + nsresult rv = NS_OK; + if (mStream) { + rv = Source()->Close(); + if (NS_FAILED(rv)) { + NS_WARNING( + "(debug) Error: Source()->Close() returned error in " + "bsBuffedInputStream::Close()."); + } + } + + nsBufferedStream::Close(); + return rv; +} + +NS_IMETHODIMP +nsBufferedInputStream::Available(uint64_t* result) { + *result = 0; + + if (!mStream) { + return NS_OK; + } + + uint64_t avail = mFillPoint - mCursor; + + uint64_t tmp; + nsresult rv = Source()->Available(&tmp); + if (NS_SUCCEEDED(rv)) { + avail += tmp; + } + + if (avail) { + *result = avail; + return NS_OK; + } + + return rv; +} + +NS_IMETHODIMP +nsBufferedInputStream::Read(char* buf, uint32_t count, uint32_t* result) { + if (mBufferDisabled) { + if (!mStream) { + *result = 0; + return NS_OK; + } + nsresult rv = Source()->Read(buf, count, result); + if (NS_SUCCEEDED(rv)) { + mBufferStartOffset += *result; // so nsBufferedStream::Tell works + if (*result == 0) { + mEOF = true; + } + } + return rv; + } + + return ReadSegments(NS_CopySegmentToBuffer, buf, count, result); +} + +NS_IMETHODIMP +nsBufferedInputStream::ReadSegments(nsWriteSegmentFun writer, void* closure, + uint32_t count, uint32_t* result) { + *result = 0; + + if (!mStream) { + return NS_OK; + } + + nsresult rv = NS_OK; + while (count > 0) { + uint32_t amt = std::min(count, mFillPoint - mCursor); + if (amt > 0) { + uint32_t read = 0; + rv = writer(static_cast<nsIBufferedInputStream*>(this), closure, + mBuffer + mCursor, *result, amt, &read); + if (NS_FAILED(rv)) { + // errors returned from the writer end here! + rv = NS_OK; + break; + } + *result += read; + count -= read; + mCursor += read; + } else { + rv = Fill(); + if (NS_FAILED(rv) || mFillPoint == mCursor) { + break; + } + } + } + return (*result > 0) ? NS_OK : rv; +} + +NS_IMETHODIMP +nsBufferedInputStream::IsNonBlocking(bool* aNonBlocking) { + if (mStream) { + return Source()->IsNonBlocking(aNonBlocking); + } + return NS_ERROR_NOT_INITIALIZED; +} + +NS_IMETHODIMP +nsBufferedInputStream::Fill() { + if (mBufferDisabled) { + return NS_OK; + } + NS_ENSURE_TRUE(mStream, NS_ERROR_NOT_INITIALIZED); + + nsresult rv; + int32_t rem = int32_t(mFillPoint - mCursor); + if (rem > 0) { + // slide the remainder down to the start of the buffer + // |<------------->|<--rem-->|<--->| + // b c f s + memcpy(mBuffer, mBuffer + mCursor, rem); + } + mBufferStartOffset += mCursor; + mFillPoint = rem; + mCursor = 0; + + uint32_t amt; + rv = Source()->Read(mBuffer + mFillPoint, mBufferSize - mFillPoint, &amt); + if (NS_FAILED(rv)) { + return rv; + } + + if (amt == 0) { + mEOF = true; + } + + mFillPoint += amt; + return NS_OK; +} + +NS_IMETHODIMP_(char*) +nsBufferedInputStream::GetBuffer(uint32_t aLength, uint32_t aAlignMask) { + NS_ASSERTION(mGetBufferCount == 0, "nested GetBuffer!"); + if (mGetBufferCount != 0) { + return nullptr; + } + + if (mBufferDisabled) { + return nullptr; + } + + char* buf = mBuffer + mCursor; + uint32_t rem = mFillPoint - mCursor; + if (rem == 0) { + if (NS_FAILED(Fill())) { + return nullptr; + } + buf = mBuffer + mCursor; + rem = mFillPoint - mCursor; + } + + uint32_t mod = (NS_PTR_TO_INT32(buf) & aAlignMask); + if (mod) { + uint32_t pad = aAlignMask + 1 - mod; + if (pad > rem) { + return nullptr; + } + + memset(buf, 0, pad); + mCursor += pad; + buf += pad; + rem -= pad; + } + + if (aLength > rem) { + return nullptr; + } + mGetBufferCount++; + return buf; +} + +NS_IMETHODIMP_(void) +nsBufferedInputStream::PutBuffer(char* aBuffer, uint32_t aLength) { + NS_ASSERTION(mGetBufferCount == 1, "stray PutBuffer!"); + if (--mGetBufferCount != 0) { + return; + } + + NS_ASSERTION(mCursor + aLength <= mFillPoint, "PutBuffer botch"); + mCursor += aLength; +} + +NS_IMETHODIMP +nsBufferedInputStream::DisableBuffering() { + NS_ASSERTION(!mBufferDisabled, "redundant call to DisableBuffering!"); + NS_ASSERTION(mGetBufferCount == 0, + "DisableBuffer call between GetBuffer and PutBuffer!"); + if (mGetBufferCount != 0) { + return NS_ERROR_UNEXPECTED; + } + + // Empty the buffer so nsBufferedStream::Tell works. + mBufferStartOffset += mCursor; + mFillPoint = mCursor = 0; + mBufferDisabled = true; + return NS_OK; +} + +NS_IMETHODIMP +nsBufferedInputStream::EnableBuffering() { + NS_ASSERTION(mBufferDisabled, "gratuitous call to EnableBuffering!"); + mBufferDisabled = false; + return NS_OK; +} + +NS_IMETHODIMP +nsBufferedInputStream::GetUnbufferedStream(nsISupports** aStream) { + // Empty the buffer so subsequent i/o trumps any buffered data. + mBufferStartOffset += mCursor; + mFillPoint = mCursor = 0; + + nsCOMPtr<nsISupports> stream = mStream; + stream.forget(aStream); + return NS_OK; +} + +void nsBufferedInputStream::Serialize( + InputStreamParams& aParams, FileDescriptorArray& aFileDescriptors, + bool aDelayedStart, uint32_t aMaxSize, uint32_t* aSizeUsed, + mozilla::ipc::ParentToChildStreamActorManager* aManager) { + SerializeInternal(aParams, aFileDescriptors, aDelayedStart, aMaxSize, + aSizeUsed, aManager); +} + +void nsBufferedInputStream::Serialize( + InputStreamParams& aParams, FileDescriptorArray& aFileDescriptors, + bool aDelayedStart, uint32_t aMaxSize, uint32_t* aSizeUsed, + mozilla::ipc::ChildToParentStreamActorManager* aManager) { + SerializeInternal(aParams, aFileDescriptors, aDelayedStart, aMaxSize, + aSizeUsed, aManager); +} + +template <typename M> +void nsBufferedInputStream::SerializeInternal( + InputStreamParams& aParams, FileDescriptorArray& aFileDescriptors, + bool aDelayedStart, uint32_t aMaxSize, uint32_t* aSizeUsed, M* aManager) { + MOZ_ASSERT(aSizeUsed); + *aSizeUsed = 0; + + BufferedInputStreamParams params; + + if (mStream) { + nsCOMPtr<nsIInputStream> stream = do_QueryInterface(mStream); + MOZ_ASSERT(stream); + + InputStreamParams wrappedParams; + InputStreamHelper::SerializeInputStream(stream, wrappedParams, + aFileDescriptors, aDelayedStart, + aMaxSize, aSizeUsed, aManager); + + params.optionalStream().emplace(wrappedParams); + } + + params.bufferSize() = mBufferSize; + + aParams = params; +} + +bool nsBufferedInputStream::Deserialize( + const InputStreamParams& aParams, + const FileDescriptorArray& aFileDescriptors) { + if (aParams.type() != InputStreamParams::TBufferedInputStreamParams) { + NS_ERROR("Received unknown parameters from the other process!"); + return false; + } + + const BufferedInputStreamParams& params = + aParams.get_BufferedInputStreamParams(); + const Maybe<InputStreamParams>& wrappedParams = params.optionalStream(); + + nsCOMPtr<nsIInputStream> stream; + if (wrappedParams.isSome()) { + stream = InputStreamHelper::DeserializeInputStream(wrappedParams.ref(), + aFileDescriptors); + if (!stream) { + NS_WARNING("Failed to deserialize wrapped stream!"); + return false; + } + } + + nsresult rv = Init(stream, params.bufferSize()); + NS_ENSURE_SUCCESS(rv, false); + + return true; +} + +NS_IMETHODIMP +nsBufferedInputStream::CloseWithStatus(nsresult aStatus) { return Close(); } + +NS_IMETHODIMP +nsBufferedInputStream::AsyncWait(nsIInputStreamCallback* aCallback, + uint32_t aFlags, uint32_t aRequestedCount, + nsIEventTarget* aEventTarget) { + nsCOMPtr<nsIAsyncInputStream> stream = do_QueryInterface(mStream); + if (!stream) { + // Stream is probably closed. Callback, if not nullptr, can be executed + // immediately + if (!aCallback) { + return NS_OK; + } + + if (aEventTarget) { + nsCOMPtr<nsIInputStreamCallback> callable = NS_NewInputStreamReadyEvent( + "nsBufferedInputStream::OnInputStreamReady", aCallback, aEventTarget); + return callable->OnInputStreamReady(this); + } + + aCallback->OnInputStreamReady(this); + return NS_OK; + } + + nsCOMPtr<nsIInputStreamCallback> callback = aCallback ? this : nullptr; + { + MutexAutoLock lock(mMutex); + + if (mAsyncWaitCallback && aCallback) { + return NS_ERROR_FAILURE; + } + + mAsyncWaitCallback = aCallback; + } + + return stream->AsyncWait(callback, aFlags, aRequestedCount, aEventTarget); +} + +NS_IMETHODIMP +nsBufferedInputStream::OnInputStreamReady(nsIAsyncInputStream* aStream) { + nsCOMPtr<nsIInputStreamCallback> callback; + { + MutexAutoLock lock(mMutex); + + // We have been canceled in the meanwhile. + if (!mAsyncWaitCallback) { + return NS_OK; + } + + callback.swap(mAsyncWaitCallback); + } + + MOZ_ASSERT(callback); + return callback->OnInputStreamReady(this); +} + +NS_IMETHODIMP +nsBufferedInputStream::GetData(nsIInputStream** aResult) { + nsCOMPtr<nsISupports> stream; + nsBufferedStream::GetData(getter_AddRefs(stream)); + nsCOMPtr<nsIInputStream> inputStream = do_QueryInterface(stream); + inputStream.forget(aResult); + return NS_OK; +} + +// nsICloneableInputStream interface + +NS_IMETHODIMP +nsBufferedInputStream::GetCloneable(bool* aCloneable) { + *aCloneable = false; + + // If we don't have the buffer, the inputStream has been already closed. + // If mBufferStartOffset is not 0, the stream has been seeked or read. + // In both case the cloning is not supported. + if (!mBuffer || mBufferStartOffset) { + return NS_OK; + } + + nsCOMPtr<nsICloneableInputStream> stream = do_QueryInterface(mStream); + + // GetCloneable is infallible. + NS_ENSURE_TRUE(stream, NS_OK); + + return stream->GetCloneable(aCloneable); +} + +NS_IMETHODIMP +nsBufferedInputStream::Clone(nsIInputStream** aResult) { + if (!mBuffer || mBufferStartOffset) { + return NS_ERROR_FAILURE; + } + + nsCOMPtr<nsICloneableInputStream> stream = do_QueryInterface(mStream); + NS_ENSURE_TRUE(stream, NS_ERROR_FAILURE); + + nsCOMPtr<nsIInputStream> clonedStream; + nsresult rv = stream->Clone(getter_AddRefs(clonedStream)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIBufferedInputStream> bis = new nsBufferedInputStream(); + rv = bis->Init(clonedStream, mBufferSize); + NS_ENSURE_SUCCESS(rv, rv); + + *aResult = + static_cast<nsBufferedInputStream*>(bis.get())->GetInputStream().take(); + + return NS_OK; +} + +// nsIInputStreamLength + +NS_IMETHODIMP +nsBufferedInputStream::Length(int64_t* aLength) { + nsCOMPtr<nsIInputStreamLength> stream = do_QueryInterface(mStream); + NS_ENSURE_TRUE(stream, NS_ERROR_FAILURE); + + return stream->Length(aLength); +} + +// nsIAsyncInputStreamLength + +NS_IMETHODIMP +nsBufferedInputStream::AsyncLengthWait(nsIInputStreamLengthCallback* aCallback, + nsIEventTarget* aEventTarget) { + nsCOMPtr<nsIAsyncInputStreamLength> stream = do_QueryInterface(mStream); + if (!stream) { + // Stream is probably closed. Callback, if not nullptr, can be executed + // immediately + if (aCallback) { + const RefPtr<nsBufferedInputStream> self = this; + const nsCOMPtr<nsIInputStreamLengthCallback> callback = aCallback; + nsCOMPtr<nsIRunnable> runnable = NS_NewRunnableFunction( + "nsBufferedInputStream::OnInputStreamLengthReady", + [self, callback] { callback->OnInputStreamLengthReady(self, -1); }); + + if (aEventTarget) { + aEventTarget->Dispatch(runnable, NS_DISPATCH_NORMAL); + } else { + runnable->Run(); + } + } + return NS_OK; + } + + nsCOMPtr<nsIInputStreamLengthCallback> callback = aCallback ? this : nullptr; + { + MutexAutoLock lock(mMutex); + mAsyncInputStreamLengthCallback = aCallback; + } + + MOZ_ASSERT(stream); + return stream->AsyncLengthWait(callback, aEventTarget); +} + +// nsIInputStreamLengthCallback + +NS_IMETHODIMP +nsBufferedInputStream::OnInputStreamLengthReady( + nsIAsyncInputStreamLength* aStream, int64_t aLength) { + nsCOMPtr<nsIInputStreamLengthCallback> callback; + { + MutexAutoLock lock(mMutex); + // We have been canceled in the meanwhile. + if (!mAsyncInputStreamLengthCallback) { + return NS_OK; + } + + callback.swap(mAsyncInputStreamLengthCallback); + } + + MOZ_ASSERT(callback); + return callback->OnInputStreamLengthReady(this, aLength); +} + +//////////////////////////////////////////////////////////////////////////////// +// nsBufferedOutputStream + +NS_IMPL_ADDREF_INHERITED(nsBufferedOutputStream, nsBufferedStream) +NS_IMPL_RELEASE_INHERITED(nsBufferedOutputStream, nsBufferedStream) +// This QI uses NS_INTERFACE_MAP_ENTRY_CONDITIONAL to check for +// non-nullness of mSafeStream. +NS_INTERFACE_MAP_BEGIN(nsBufferedOutputStream) + NS_INTERFACE_MAP_ENTRY(nsIOutputStream) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsISafeOutputStream, mSafeStream) + NS_INTERFACE_MAP_ENTRY(nsIBufferedOutputStream) + NS_INTERFACE_MAP_ENTRY(nsIStreamBufferAccess) +NS_INTERFACE_MAP_END_INHERITING(nsBufferedStream) + +nsresult nsBufferedOutputStream::Create(nsISupports* aOuter, REFNSIID aIID, + void** aResult) { + NS_ENSURE_NO_AGGREGATION(aOuter); + + RefPtr<nsBufferedOutputStream> stream = new nsBufferedOutputStream(); + return stream->QueryInterface(aIID, aResult); +} + +NS_IMETHODIMP +nsBufferedOutputStream::Init(nsIOutputStream* stream, uint32_t bufferSize) { + // QI stream to an nsISafeOutputStream, to see if we should support it + mSafeStream = do_QueryInterface(stream); + + return nsBufferedStream::Init(stream, bufferSize); +} + +NS_IMETHODIMP +nsBufferedOutputStream::Close() { + nsresult rv1, rv2 = NS_OK; + + rv1 = Flush(); + +#ifdef DEBUG + if (NS_FAILED(rv1)) { + NS_WARNING( + "(debug) Flush() inside nsBufferedOutputStream::Close() returned error " + "(rv1)."); + } +#endif + + // If we fail to Flush all the data, then we close anyway and drop the + // remaining data in the buffer. We do this because it's what Unix does + // for fclose and close. However, we report the error from Flush anyway. + if (mStream) { + rv2 = Sink()->Close(); +#ifdef DEBUG + if (NS_FAILED(rv2)) { + NS_WARNING( + "(debug) Sink->Close() inside nsBufferedOutputStream::Close() " + "returned error (rv2)."); + } +#endif + } + nsBufferedStream::Close(); + + if (NS_FAILED(rv1)) { + return rv1; + } + if (NS_FAILED(rv2)) { + return rv2; + } + return NS_OK; +} + +NS_IMETHODIMP +nsBufferedOutputStream::Write(const char* buf, uint32_t count, + uint32_t* result) { + nsresult rv = NS_OK; + uint32_t written = 0; + *result = 0; + if (!mStream) { + // We special case this situation. + // We should catch the failure, NS_BASE_STREAM_CLOSED ASAP, here. + // If we don't, eventually Flush() is called in the while loop below + // after so many writes. + // However, Flush() returns NS_OK when mStream is null (!!), + // and we don't get a meaningful error, NS_BASE_STREAM_CLOSED, + // soon enough when we use buffered output. +#ifdef DEBUG + NS_WARNING( + "(info) nsBufferedOutputStream::Write returns NS_BASE_STREAM_CLOSED " + "immediately (mStream==null)."); +#endif + return NS_BASE_STREAM_CLOSED; + } + + while (count > 0) { + uint32_t amt = std::min(count, mBufferSize - mCursor); + if (amt > 0) { + memcpy(mBuffer + mCursor, buf + written, amt); + written += amt; + count -= amt; + mCursor += amt; + if (mFillPoint < mCursor) mFillPoint = mCursor; + } else { + NS_ASSERTION(mFillPoint, "loop in nsBufferedOutputStream::Write!"); + rv = Flush(); + if (NS_FAILED(rv)) { +#ifdef DEBUG + NS_WARNING( + "(debug) Flush() returned error in nsBufferedOutputStream::Write."); +#endif + break; + } + } + } + *result = written; + return (written > 0) ? NS_OK : rv; +} + +NS_IMETHODIMP +nsBufferedOutputStream::Flush() { + nsresult rv; + uint32_t amt; + if (!mStream) { + // Stream already cancelled/flushed; probably because of previous error. + return NS_OK; + } + // optimize : some code within C-C needs to call Seek -> Flush() often. + if (mFillPoint == 0) { + return NS_OK; + } + rv = Sink()->Write(mBuffer, mFillPoint, &amt); + if (NS_FAILED(rv)) { + return rv; + } + mBufferStartOffset += amt; + if (amt == mFillPoint) { + mFillPoint = mCursor = 0; + return NS_OK; // flushed everything + } + + // slide the remainder down to the start of the buffer + // |<-------------->|<---|----->| + // b a c s + uint32_t rem = mFillPoint - amt; + memmove(mBuffer, mBuffer + amt, rem); + mFillPoint = mCursor = rem; + return NS_ERROR_FAILURE; // didn't flush all +} + +// nsISafeOutputStream +NS_IMETHODIMP +nsBufferedOutputStream::Finish() { + // flush the stream, to write out any buffered data... + nsresult rv1 = nsBufferedOutputStream::Flush(); + nsresult rv2 = NS_OK; + + if (NS_FAILED(rv1)) { + NS_WARNING( + "(debug) nsBufferedOutputStream::Flush() failed in " + "nsBufferedOutputStream::Finish()! Possible dataloss."); + + rv2 = Sink()->Close(); + if (NS_FAILED(rv2)) { + NS_WARNING( + "(debug) Sink()->Close() failed in nsBufferedOutputStream::Finish()! " + "Possible dataloss."); + } + } else { + rv2 = mSafeStream->Finish(); + if (NS_FAILED(rv2)) { + NS_WARNING( + "(debug) mSafeStream->Finish() failed within " + "nsBufferedOutputStream::Flush()! Possible dataloss."); + } + } + + // ... and close the buffered stream, so any further attempts to flush/close + // the buffered stream won't cause errors. + nsBufferedStream::Close(); + + // We want to return the errors precisely from Finish() + // and mimick the existing error handling in + // nsBufferedOutputStream::Close() as reference. + + if (NS_FAILED(rv1)) { + return rv1; + } + if (NS_FAILED(rv2)) { + return rv2; + } + return NS_OK; +} + +static nsresult nsReadFromInputStream(nsIOutputStream* outStr, void* closure, + char* toRawSegment, uint32_t offset, + uint32_t count, uint32_t* readCount) { + nsIInputStream* fromStream = (nsIInputStream*)closure; + return fromStream->Read(toRawSegment, count, readCount); +} + +NS_IMETHODIMP +nsBufferedOutputStream::WriteFrom(nsIInputStream* inStr, uint32_t count, + uint32_t* _retval) { + return WriteSegments(nsReadFromInputStream, inStr, count, _retval); +} + +NS_IMETHODIMP +nsBufferedOutputStream::WriteSegments(nsReadSegmentFun reader, void* closure, + uint32_t count, uint32_t* _retval) { + *_retval = 0; + nsresult rv; + while (count > 0) { + uint32_t left = std::min(count, mBufferSize - mCursor); + if (left == 0) { + rv = Flush(); + if (NS_FAILED(rv)) { + return (*_retval > 0) ? NS_OK : rv; + } + + continue; + } + + uint32_t read = 0; + rv = reader(this, closure, mBuffer + mCursor, *_retval, left, &read); + + if (NS_FAILED(rv)) { // If we have read some data, return ok + return (*_retval > 0) ? NS_OK : rv; + } + mCursor += read; + *_retval += read; + count -= read; + mFillPoint = std::max(mFillPoint, mCursor); + } + return NS_OK; +} + +NS_IMETHODIMP +nsBufferedOutputStream::IsNonBlocking(bool* aNonBlocking) { + if (mStream) { + return Sink()->IsNonBlocking(aNonBlocking); + } + return NS_ERROR_NOT_INITIALIZED; +} + +NS_IMETHODIMP_(char*) +nsBufferedOutputStream::GetBuffer(uint32_t aLength, uint32_t aAlignMask) { + NS_ASSERTION(mGetBufferCount == 0, "nested GetBuffer!"); + if (mGetBufferCount != 0) { + return nullptr; + } + + if (mBufferDisabled) { + return nullptr; + } + + char* buf = mBuffer + mCursor; + uint32_t rem = mBufferSize - mCursor; + if (rem == 0) { + if (NS_FAILED(Flush())) { + return nullptr; + } + buf = mBuffer + mCursor; + rem = mBufferSize - mCursor; + } + + uint32_t mod = (NS_PTR_TO_INT32(buf) & aAlignMask); + if (mod) { + uint32_t pad = aAlignMask + 1 - mod; + if (pad > rem) { + return nullptr; + } + + memset(buf, 0, pad); + mCursor += pad; + buf += pad; + rem -= pad; + } + + if (aLength > rem) { + return nullptr; + } + mGetBufferCount++; + return buf; +} + +NS_IMETHODIMP_(void) +nsBufferedOutputStream::PutBuffer(char* aBuffer, uint32_t aLength) { + NS_ASSERTION(mGetBufferCount == 1, "stray PutBuffer!"); + if (--mGetBufferCount != 0) { + return; + } + + NS_ASSERTION(mCursor + aLength <= mBufferSize, "PutBuffer botch"); + mCursor += aLength; + if (mFillPoint < mCursor) { + mFillPoint = mCursor; + } +} + +NS_IMETHODIMP +nsBufferedOutputStream::DisableBuffering() { + NS_ASSERTION(!mBufferDisabled, "redundant call to DisableBuffering!"); + NS_ASSERTION(mGetBufferCount == 0, + "DisableBuffer call between GetBuffer and PutBuffer!"); + if (mGetBufferCount != 0) { + return NS_ERROR_UNEXPECTED; + } + + // Empty the buffer so nsBufferedStream::Tell works. + nsresult rv = Flush(); + if (NS_FAILED(rv)) { + return rv; + } + + mBufferDisabled = true; + return NS_OK; +} + +NS_IMETHODIMP +nsBufferedOutputStream::EnableBuffering() { + NS_ASSERTION(mBufferDisabled, "gratuitous call to EnableBuffering!"); + mBufferDisabled = false; + return NS_OK; +} + +NS_IMETHODIMP +nsBufferedOutputStream::GetUnbufferedStream(nsISupports** aStream) { + // Empty the buffer so subsequent i/o trumps any buffered data. + if (mFillPoint) { + nsresult rv = Flush(); + if (NS_FAILED(rv)) { + return rv; + } + } + + nsCOMPtr<nsISupports> stream = mStream; + stream.forget(aStream); + return NS_OK; +} + +NS_IMETHODIMP +nsBufferedOutputStream::GetData(nsIOutputStream** aResult) { + nsCOMPtr<nsISupports> stream; + nsBufferedStream::GetData(getter_AddRefs(stream)); + nsCOMPtr<nsIOutputStream> outputStream = do_QueryInterface(stream); + outputStream.forget(aResult); + return NS_OK; +} +#undef METER + +//////////////////////////////////////////////////////////////////////////////// diff --git a/netwerk/base/nsBufferedStreams.h b/netwerk/base/nsBufferedStreams.h new file mode 100644 index 0000000000..93868d3c20 --- /dev/null +++ b/netwerk/base/nsBufferedStreams.h @@ -0,0 +1,167 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef nsBufferedStreams_h__ +#define nsBufferedStreams_h__ + +#include "nsIBufferedStreams.h" +#include "nsIInputStream.h" +#include "nsIOutputStream.h" +#include "nsISafeOutputStream.h" +#include "nsISeekableStream.h" +#include "nsIStreamBufferAccess.h" +#include "nsCOMPtr.h" +#include "nsIIPCSerializableInputStream.h" +#include "nsIAsyncInputStream.h" +#include "nsICloneableInputStream.h" +#include "nsIInputStreamLength.h" +#include "mozilla/Mutex.h" + +//////////////////////////////////////////////////////////////////////////////// + +class nsBufferedStream : public nsISeekableStream { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSISEEKABLESTREAM + NS_DECL_NSITELLABLESTREAM + + nsBufferedStream(); + + void Close(); + + protected: + virtual ~nsBufferedStream(); + + nsresult Init(nsISupports* stream, uint32_t bufferSize); + nsresult GetData(nsISupports** aResult); + NS_IMETHOD Fill() = 0; + NS_IMETHOD Flush() = 0; + + uint32_t mBufferSize; + char* mBuffer; + + // mBufferStartOffset is the offset relative to the start of mStream. + int64_t mBufferStartOffset; + + // mCursor is the read cursor for input streams, or write cursor for + // output streams, and is relative to mBufferStartOffset. + uint32_t mCursor; + + // mFillPoint is the amount available in the buffer for input streams, + // or the high watermark of bytes written into the buffer, and therefore + // is relative to mBufferStartOffset. + uint32_t mFillPoint; + + nsCOMPtr<nsISupports> mStream; // cast to appropriate subclass + + bool mBufferDisabled; + bool mEOF; // True if mStream is at EOF + uint8_t mGetBufferCount; +}; + +//////////////////////////////////////////////////////////////////////////////// + +class nsBufferedInputStream final : public nsBufferedStream, + public nsIBufferedInputStream, + public nsIStreamBufferAccess, + public nsIIPCSerializableInputStream, + public nsIAsyncInputStream, + public nsIInputStreamCallback, + public nsICloneableInputStream, + public nsIInputStreamLength, + public nsIAsyncInputStreamLength, + public nsIInputStreamLengthCallback { + public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_NSIINPUTSTREAM + NS_DECL_NSIBUFFEREDINPUTSTREAM + NS_DECL_NSISTREAMBUFFERACCESS + NS_DECL_NSIIPCSERIALIZABLEINPUTSTREAM + NS_DECL_NSIASYNCINPUTSTREAM + NS_DECL_NSIINPUTSTREAMCALLBACK + NS_DECL_NSICLONEABLEINPUTSTREAM + NS_DECL_NSIINPUTSTREAMLENGTH + NS_DECL_NSIASYNCINPUTSTREAMLENGTH + NS_DECL_NSIINPUTSTREAMLENGTHCALLBACK + + nsBufferedInputStream(); + + static nsresult Create(nsISupports* aOuter, REFNSIID aIID, void** aResult); + + nsIInputStream* Source() { return (nsIInputStream*)mStream.get(); } + + /** + * If there's a reference/pointer to an nsBufferedInputStream BEFORE calling + * Init() AND the intent is to ultimately convert/assign that + * reference/pointer to an nsIInputStream, DO NOT use that initial + * reference/pointer. Instead, use the value of QueryInterface-ing to an + * nsIInputStream (and, again, the QueryInterface must be performed after + * Init()). This is because nsBufferedInputStream has multiple underlying + * nsIInputStreams (one from nsIBufferedInputStream and one from + * nsIAsyncInputStream), and the correct base nsIInputStream to use will be + * unknown until the final value of mIsAsyncInputStream is set in Init(). + * + * This method, however, does just that but also hides the QI details and + * will assert if called before Init(). + */ + already_AddRefed<nsIInputStream> GetInputStream(); + + protected: + virtual ~nsBufferedInputStream() = default; + + template <typename M> + void SerializeInternal(mozilla::ipc::InputStreamParams& aParams, + FileDescriptorArray& aFileDescriptors, + bool aDelayedStart, uint32_t aMaxSize, + uint32_t* aSizeUsed, M* aManager); + + NS_IMETHOD Fill() override; + NS_IMETHOD Flush() override { return NS_OK; } // no-op for input streams + + mozilla::Mutex mMutex; + + // This value is protected by mutex. + nsCOMPtr<nsIInputStreamCallback> mAsyncWaitCallback; + + // This value is protected by mutex. + nsCOMPtr<nsIInputStreamLengthCallback> mAsyncInputStreamLengthCallback; + + bool mIsIPCSerializable; + bool mIsAsyncInputStream; + bool mIsCloneableInputStream; + bool mIsInputStreamLength; + bool mIsAsyncInputStreamLength; +}; + +//////////////////////////////////////////////////////////////////////////////// + +class nsBufferedOutputStream : public nsBufferedStream, + public nsISafeOutputStream, + public nsIBufferedOutputStream, + public nsIStreamBufferAccess { + public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_NSIOUTPUTSTREAM + NS_DECL_NSISAFEOUTPUTSTREAM + NS_DECL_NSIBUFFEREDOUTPUTSTREAM + NS_DECL_NSISTREAMBUFFERACCESS + + nsBufferedOutputStream() : nsBufferedStream() {} + + static nsresult Create(nsISupports* aOuter, REFNSIID aIID, void** aResult); + + nsIOutputStream* Sink() { return (nsIOutputStream*)mStream.get(); } + + protected: + virtual ~nsBufferedOutputStream() { nsBufferedOutputStream::Close(); } + + NS_IMETHOD Fill() override { return NS_OK; } // no-op for output streams + + nsCOMPtr<nsISafeOutputStream> mSafeStream; // QI'd from mStream +}; + +//////////////////////////////////////////////////////////////////////////////// + +#endif // nsBufferedStreams_h__ diff --git a/netwerk/base/nsDNSPrefetch.cpp b/netwerk/base/nsDNSPrefetch.cpp new file mode 100644 index 0000000000..529171a347 --- /dev/null +++ b/netwerk/base/nsDNSPrefetch.cpp @@ -0,0 +1,162 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "nsDNSPrefetch.h" +#include "nsCOMPtr.h" +#include "nsString.h" +#include "nsThreadUtils.h" + +#include "nsIDNSListener.h" +#include "nsIDNSService.h" +#include "nsIDNSByTypeRecord.h" +#include "nsICancelable.h" +#include "nsIURI.h" +#include "mozilla/Atomics.h" +#include "mozilla/Preferences.h" + +static nsIDNSService* sDNSService = nullptr; + +nsresult nsDNSPrefetch::Initialize(nsIDNSService* aDNSService) { + MOZ_ASSERT(NS_IsMainThread()); + + NS_IF_RELEASE(sDNSService); + sDNSService = aDNSService; + NS_IF_ADDREF(sDNSService); + return NS_OK; +} + +nsresult nsDNSPrefetch::Shutdown() { + NS_IF_RELEASE(sDNSService); + return NS_OK; +} + +nsDNSPrefetch::nsDNSPrefetch(nsIURI* aURI, + mozilla::OriginAttributes& aOriginAttributes, + nsIRequest::TRRMode aTRRMode, + nsIDNSListener* aListener, bool storeTiming) + : mOriginAttributes(aOriginAttributes), + mStoreTiming(storeTiming), + mTRRMode(aTRRMode), + mListener(do_GetWeakReference(aListener)) { + aURI->GetAsciiHost(mHostname); +} + +nsDNSPrefetch::nsDNSPrefetch(nsIURI* aURI, + mozilla::OriginAttributes& aOriginAttributes, + nsIRequest::TRRMode aTRRMode) + : mOriginAttributes(aOriginAttributes), + mStoreTiming(false), + mTRRMode(aTRRMode), + mListener(nullptr) { + aURI->GetAsciiHost(mHostname); +} + +nsresult nsDNSPrefetch::Prefetch(uint32_t flags) { + if (mHostname.IsEmpty()) return NS_ERROR_NOT_AVAILABLE; + + if (!sDNSService) return NS_ERROR_NOT_AVAILABLE; + + nsCOMPtr<nsICancelable> tmpOutstanding; + + if (mStoreTiming) mStartTimestamp = mozilla::TimeStamp::Now(); + // If AsyncResolve fails, for example because prefetching is disabled, + // then our timing will be useless. However, in such a case, + // mEndTimestamp will be a null timestamp and callers should check + // TimingsValid() before using the timing. + nsCOMPtr<nsIEventTarget> target = mozilla::GetCurrentEventTarget(); + + flags |= nsIDNSService::GetFlagsFromTRRMode(mTRRMode); + + return sDNSService->AsyncResolveNative( + mHostname, nsIDNSService::RESOLVE_TYPE_DEFAULT, + flags | nsIDNSService::RESOLVE_SPECULATE, nullptr, this, target, + mOriginAttributes, getter_AddRefs(tmpOutstanding)); +} + +nsresult nsDNSPrefetch::PrefetchLow(bool refreshDNS) { + return Prefetch(nsIDNSService::RESOLVE_PRIORITY_LOW | + (refreshDNS ? nsIDNSService::RESOLVE_BYPASS_CACHE : 0)); +} + +nsresult nsDNSPrefetch::PrefetchMedium(bool refreshDNS) { + return Prefetch(nsIDNSService::RESOLVE_PRIORITY_MEDIUM | + (refreshDNS ? nsIDNSService::RESOLVE_BYPASS_CACHE : 0)); +} + +nsresult nsDNSPrefetch::PrefetchHigh(bool refreshDNS) { + return Prefetch(refreshDNS ? nsIDNSService::RESOLVE_BYPASS_CACHE : 0); +} + +namespace { + +class HTTPSRRListener final : public nsIDNSListener { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIDNSLISTENER + + explicit HTTPSRRListener( + std::function<void(nsIDNSHTTPSSVCRecord*)>&& aCallback) + : mResultCallback(std::move(aCallback)) {} + + private: + ~HTTPSRRListener() = default; + std::function<void(nsIDNSHTTPSSVCRecord*)> mResultCallback; +}; + +NS_IMPL_ISUPPORTS(HTTPSRRListener, nsIDNSListener) + +NS_IMETHODIMP +HTTPSRRListener::OnLookupComplete(nsICancelable* aRequest, nsIDNSRecord* aRec, + nsresult aStatus) { + if (NS_FAILED(aStatus)) { + mResultCallback(nullptr); + return NS_OK; + } + + nsCOMPtr<nsIDNSHTTPSSVCRecord> httpsRecord = do_QueryInterface(aRec); + mResultCallback(httpsRecord); + return NS_OK; +} + +}; // namespace + +nsresult nsDNSPrefetch::FetchHTTPSSVC( + bool aRefreshDNS, bool aPrefetch, + std::function<void(nsIDNSHTTPSSVCRecord*)>&& aCallback) { + if (!sDNSService) { + return NS_ERROR_NOT_AVAILABLE; + } + + nsCOMPtr<nsIEventTarget> target = mozilla::GetCurrentEventTarget(); + uint32_t flags = nsIDNSService::GetFlagsFromTRRMode(mTRRMode); + if (aRefreshDNS) { + flags |= nsIDNSService::RESOLVE_BYPASS_CACHE; + } + if (aPrefetch) { + flags |= nsIDNSService::RESOLVE_SPECULATE; + } + + nsCOMPtr<nsICancelable> tmpOutstanding; + nsCOMPtr<nsIDNSListener> listener = new HTTPSRRListener(std::move(aCallback)); + return sDNSService->AsyncResolveNative( + mHostname, nsIDNSService::RESOLVE_TYPE_HTTPSSVC, flags, nullptr, listener, + target, mOriginAttributes, getter_AddRefs(tmpOutstanding)); +} + +NS_IMPL_ISUPPORTS(nsDNSPrefetch, nsIDNSListener) + +NS_IMETHODIMP +nsDNSPrefetch::OnLookupComplete(nsICancelable* request, nsIDNSRecord* rec, + nsresult status) { + if (mStoreTiming) { + mEndTimestamp = mozilla::TimeStamp::Now(); + } + nsCOMPtr<nsIDNSListener> listener = do_QueryReferent(mListener); + if (listener) { + listener->OnLookupComplete(request, rec, status); + } + + return NS_OK; +} diff --git a/netwerk/base/nsDNSPrefetch.h b/netwerk/base/nsDNSPrefetch.h new file mode 100644 index 0000000000..03d6305b71 --- /dev/null +++ b/netwerk/base/nsDNSPrefetch.h @@ -0,0 +1,68 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef nsDNSPrefetch_h___ +#define nsDNSPrefetch_h___ + +#include <functional> + +#include "nsIWeakReferenceUtils.h" +#include "nsString.h" +#include "mozilla/TimeStamp.h" +#include "mozilla/Attributes.h" +#include "mozilla/BasePrincipal.h" + +#include "nsIDNSListener.h" +#include "nsIRequest.h" + +class nsIURI; +class nsIDNSService; +class nsIDNSHTTPSSVCRecord; + +class nsDNSPrefetch final : public nsIDNSListener { + ~nsDNSPrefetch() = default; + + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIDNSLISTENER + + nsDNSPrefetch(nsIURI* aURI, mozilla::OriginAttributes& aOriginAttributes, + nsIRequest::TRRMode aTRRMode, nsIDNSListener* aListener, + bool storeTiming); + // For fetching HTTPS RR. + nsDNSPrefetch(nsIURI* aURI, mozilla::OriginAttributes& aOriginAttributes, + nsIRequest::TRRMode aTRRMode); + bool TimingsValid() const { + return !mStartTimestamp.IsNull() && !mEndTimestamp.IsNull(); + } + // Only use the two timings if TimingsValid() returns true + const mozilla::TimeStamp& StartTimestamp() const { return mStartTimestamp; } + const mozilla::TimeStamp& EndTimestamp() const { return mEndTimestamp; } + + static nsresult Initialize(nsIDNSService* aDNSService); + static nsresult Shutdown(); + + // Call one of the following methods to start the Prefetch. + nsresult PrefetchHigh(bool refreshDNS = false); + nsresult PrefetchMedium(bool refreshDNS = false); + nsresult PrefetchLow(bool refreshDNS = false); + + nsresult FetchHTTPSSVC( + bool aRefreshDNS, bool aPrefetch, + std::function<void(nsIDNSHTTPSSVCRecord*)>&& aCallback); + + private: + nsCString mHostname; + mozilla::OriginAttributes mOriginAttributes; + bool mStoreTiming; + nsIRequest::TRRMode mTRRMode; + mozilla::TimeStamp mStartTimestamp; + mozilla::TimeStamp mEndTimestamp; + nsWeakPtr mListener; + + nsresult Prefetch(uint32_t flags); +}; + +#endif diff --git a/netwerk/base/nsDirectoryIndexStream.cpp b/netwerk/base/nsDirectoryIndexStream.cpp new file mode 100644 index 0000000000..9ae629a6bd --- /dev/null +++ b/netwerk/base/nsDirectoryIndexStream.cpp @@ -0,0 +1,321 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set sw=2 sts=2 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/. */ + +/* + + The converts a filesystem directory into an "HTTP index" stream per + Lou Montulli's original spec: + + http://www.mozilla.org/projects/netlib/dirindexformat.html + + */ + +#include "nsEscape.h" +#include "nsDirectoryIndexStream.h" +#include "mozilla/Logging.h" +#include "prtime.h" +#ifdef THREADSAFE_I18N +# include "nsCollationCID.h" +# include "nsICollation.h" +#endif +#include "nsIFile.h" +#include "nsURLHelper.h" +#include "nsNativeCharsetUtils.h" + +// NOTE: This runs on the _file transport_ thread. +// The problem is that now that we're actually doing something with the data, +// we want to do stuff like i18n sorting. However, none of the collation stuff +// is threadsafe. +// So THIS CODE IS ASCII ONLY!!!!!!!! This is no worse than the current +// behaviour, though. See bug 99382. +// When this is fixed, #define THREADSAFE_I18N to get this code working + +//#define THREADSAFE_I18N + +using namespace mozilla; +static LazyLogModule gLog("nsDirectoryIndexStream"); + +nsDirectoryIndexStream::nsDirectoryIndexStream() + : mOffset(0), mStatus(NS_OK), mPos(0) { + MOZ_LOG(gLog, LogLevel::Debug, ("nsDirectoryIndexStream[%p]: created", this)); +} + +static int compare(nsIFile* aElement1, nsIFile* aElement2, void* aData) { + if (!NS_IsNativeUTF8()) { + // don't check for errors, because we can't report them anyway + nsAutoString name1, name2; + aElement1->GetLeafName(name1); + aElement2->GetLeafName(name2); + + // Note - we should do the collation to do sorting. Why don't we? + // Because that is _slow_. Using TestProtocols to list file:///dev/ + // goes from 3 seconds to 22. (This may be why nsXULSortService is + // so slow as well). + // Does this have bad effects? Probably, but since nsXULTree appears + // to use the raw RDF literal value as the sort key (which ammounts to an + // strcmp), it won't be any worse, I think. + // This could be made faster, by creating the keys once, + // but CompareString could still be smarter - see bug 99383 - bbaetz + // NB - 99393 has been WONTFIXed. So if the I18N code is ever made + // threadsafe so that this matters, we'd have to pass through a + // struct { nsIFile*, uint8_t* } with the pre-calculated key. + return Compare(name1, name2); + } + + nsAutoCString name1, name2; + aElement1->GetNativeLeafName(name1); + aElement2->GetNativeLeafName(name2); + + return Compare(name1, name2); +} + +nsresult nsDirectoryIndexStream::Init(nsIFile* aDir) { + nsresult rv; + bool isDir; + rv = aDir->IsDirectory(&isDir); + if (NS_FAILED(rv)) return rv; + MOZ_ASSERT(isDir, "not a directory"); + if (!isDir) return NS_ERROR_ILLEGAL_VALUE; + + if (MOZ_LOG_TEST(gLog, LogLevel::Debug)) { + MOZ_LOG(gLog, LogLevel::Debug, + ("nsDirectoryIndexStream[%p]: initialized on %s", this, + aDir->HumanReadablePath().get())); + } + + // Sigh. We have to allocate on the heap because there are no + // assignment operators defined. + nsCOMPtr<nsIDirectoryEnumerator> iter; + rv = aDir->GetDirectoryEntries(getter_AddRefs(iter)); + if (NS_FAILED(rv)) return rv; + + // Now lets sort, because clients expect it that way + // XXX - should we do so here, or when the first item is requested? + // XXX - use insertion sort instead? + + nsCOMPtr<nsIFile> file; + while (NS_SUCCEEDED(iter->GetNextFile(getter_AddRefs(file))) && file) { + mArray.AppendObject(file); // addrefs + } + +#ifdef THREADSAFE_I18N + nsCOMPtr<nsICollationFactory> cf = + do_CreateInstance(NS_COLLATIONFACTORY_CONTRACTID, &rv); + if (NS_FAILED(rv)) return rv; + + nsCOMPtr<nsICollation> coll; + rv = cf->CreateCollation(getter_AddRefs(coll)); + if (NS_FAILED(rv)) return rv; + + mArray.Sort(compare, coll); +#else + mArray.Sort(compare, nullptr); +#endif + + mBuf.AppendLiteral("300: "); + nsAutoCString url; + rv = net_GetURLSpecFromFile(aDir, url); + if (NS_FAILED(rv)) return rv; + mBuf.Append(url); + mBuf.Append('\n'); + + mBuf.AppendLiteral("200: filename content-length last-modified file-type\n"); + + return NS_OK; +} + +nsDirectoryIndexStream::~nsDirectoryIndexStream() { + MOZ_LOG(gLog, LogLevel::Debug, + ("nsDirectoryIndexStream[%p]: destroyed", this)); +} + +nsresult nsDirectoryIndexStream::Create(nsIFile* aDir, + nsIInputStream** aResult) { + RefPtr<nsDirectoryIndexStream> result = new nsDirectoryIndexStream(); + if (!result) return NS_ERROR_OUT_OF_MEMORY; + + nsresult rv = result->Init(aDir); + if (NS_FAILED(rv)) { + return rv; + } + + result.forget(aResult); + return NS_OK; +} + +NS_IMPL_ISUPPORTS(nsDirectoryIndexStream, nsIInputStream) + +// The below routines are proxied to the UI thread! +NS_IMETHODIMP +nsDirectoryIndexStream::Close() { + mStatus = NS_BASE_STREAM_CLOSED; + return NS_OK; +} + +NS_IMETHODIMP +nsDirectoryIndexStream::Available(uint64_t* aLength) { + if (NS_FAILED(mStatus)) return mStatus; + + // If there's data in our buffer, use that + if (mOffset < (int32_t)mBuf.Length()) { + *aLength = mBuf.Length() - mOffset; + return NS_OK; + } + + // Returning one byte is not ideal, but good enough + *aLength = (mPos < mArray.Count()) ? 1 : 0; + return NS_OK; +} + +NS_IMETHODIMP +nsDirectoryIndexStream::Read(char* aBuf, uint32_t aCount, + uint32_t* aReadCount) { + if (mStatus == NS_BASE_STREAM_CLOSED) { + *aReadCount = 0; + return NS_OK; + } + if (NS_FAILED(mStatus)) return mStatus; + + uint32_t nread = 0; + + // If anything is enqueued (or left-over) in mBuf, then feed it to + // the reader first. + while (mOffset < (int32_t)mBuf.Length() && aCount != 0) { + *(aBuf++) = char(mBuf.CharAt(mOffset++)); + --aCount; + ++nread; + } + + // Room left? + if (aCount > 0) { + mOffset = 0; + mBuf.Truncate(); + + // Okay, now we'll suck stuff off of our iterator into the mBuf... + while (uint32_t(mBuf.Length()) < aCount) { + bool more = mPos < mArray.Count(); + if (!more) break; + + // don't addref, for speed - an addref happened when it + // was placed in the array, so it's not going to go stale + nsIFile* current = mArray.ObjectAt(mPos); + ++mPos; + + if (MOZ_LOG_TEST(gLog, LogLevel::Debug)) { + MOZ_LOG(gLog, LogLevel::Debug, + ("nsDirectoryIndexStream[%p]: iterated %s", this, + current->HumanReadablePath().get())); + } + + // rjc: don't return hidden files/directories! + // bbaetz: why not? + nsresult rv; +#ifndef XP_UNIX + bool hidden = false; + current->IsHidden(&hidden); + if (hidden) { + MOZ_LOG(gLog, LogLevel::Debug, + ("nsDirectoryIndexStream[%p]: skipping hidden file/directory", + this)); + continue; + } +#endif + + int64_t fileSize = 0; + current->GetFileSize(&fileSize); + + PRTime fileInfoModifyTime = 0; + current->GetLastModifiedTime(&fileInfoModifyTime); + fileInfoModifyTime *= PR_USEC_PER_MSEC; + + mBuf.AppendLiteral("201: "); + + // The "filename" field + if (!NS_IsNativeUTF8()) { + nsAutoString leafname; + rv = current->GetLeafName(leafname); + if (NS_FAILED(rv)) return rv; + + nsAutoCString escaped; + if (!leafname.IsEmpty() && + NS_Escape(NS_ConvertUTF16toUTF8(leafname), escaped, url_Path)) { + mBuf.Append(escaped); + mBuf.Append(' '); + } + } else { + nsAutoCString leafname; + rv = current->GetNativeLeafName(leafname); + if (NS_FAILED(rv)) return rv; + + nsAutoCString escaped; + if (!leafname.IsEmpty() && NS_Escape(leafname, escaped, url_Path)) { + mBuf.Append(escaped); + mBuf.Append(' '); + } + } + + // The "content-length" field + mBuf.AppendInt(fileSize, 10); + mBuf.Append(' '); + + // The "last-modified" field + PRExplodedTime tm; + PR_ExplodeTime(fileInfoModifyTime, PR_GMTParameters, &tm); + { + char buf[64]; + PR_FormatTimeUSEnglish( + buf, sizeof(buf), "%a,%%20%d%%20%b%%20%Y%%20%H:%M:%S%%20GMT ", &tm); + mBuf.Append(buf); + } + + // The "file-type" field + bool isFile = true; + current->IsFile(&isFile); + if (isFile) { + mBuf.AppendLiteral("FILE "); + } else { + bool isDir; + rv = current->IsDirectory(&isDir); + if (NS_FAILED(rv)) return rv; + if (isDir) { + mBuf.AppendLiteral("DIRECTORY "); + } else { + bool isLink; + rv = current->IsSymlink(&isLink); + if (NS_FAILED(rv)) return rv; + if (isLink) { + mBuf.AppendLiteral("SYMBOLIC-LINK "); + } + } + } + + mBuf.Append('\n'); + } + + // ...and once we've either run out of directory entries, or + // filled up the buffer, then we'll push it to the reader. + while (mOffset < (int32_t)mBuf.Length() && aCount != 0) { + *(aBuf++) = char(mBuf.CharAt(mOffset++)); + --aCount; + ++nread; + } + } + + *aReadCount = nread; + return NS_OK; +} + +NS_IMETHODIMP +nsDirectoryIndexStream::ReadSegments(nsWriteSegmentFun writer, void* closure, + uint32_t count, uint32_t* _retval) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsDirectoryIndexStream::IsNonBlocking(bool* aNonBlocking) { + *aNonBlocking = false; + return NS_OK; +} diff --git a/netwerk/base/nsDirectoryIndexStream.h b/netwerk/base/nsDirectoryIndexStream.h new file mode 100644 index 0000000000..8e4721300c --- /dev/null +++ b/netwerk/base/nsDirectoryIndexStream.h @@ -0,0 +1,46 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef nsDirectoryIndexStream_h__ +#define nsDirectoryIndexStream_h__ + +#include "mozilla/Attributes.h" + +#include "nsString.h" +#include "nsIInputStream.h" +#include "nsCOMArray.h" + +class nsIFile; + +class nsDirectoryIndexStream final : public nsIInputStream { + private: + nsCString mBuf; + int32_t mOffset; + nsresult mStatus; + + int32_t mPos; // position within mArray + nsCOMArray<nsIFile> mArray; // file objects within the directory + + nsDirectoryIndexStream(); + /** + * aDir will only be used on the calling thread. + */ + nsresult Init(nsIFile* aDir); + ~nsDirectoryIndexStream(); + + public: + /** + * aDir will only be used on the calling thread. + */ + static nsresult Create(nsIFile* aDir, nsIInputStream** aStreamResult); + + // nsISupportsInterface + NS_DECL_THREADSAFE_ISUPPORTS + + // nsIInputStream interface + NS_DECL_NSIINPUTSTREAM +}; + +#endif // nsDirectoryIndexStream_h__ diff --git a/netwerk/base/nsDownloader.cpp b/netwerk/base/nsDownloader.cpp new file mode 100644 index 0000000000..670459e710 --- /dev/null +++ b/netwerk/base/nsDownloader.cpp @@ -0,0 +1,97 @@ +/* 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 "nsDownloader.h" +#include "nsIInputStream.h" +#include "nsDirectoryServiceUtils.h" +#include "nsDirectoryServiceDefs.h" +#include "nsNetUtil.h" +#include "nsCRTGlue.h" + +nsDownloader::~nsDownloader() { + if (mLocation && mLocationIsTemp) { + // release the sink first since it may still hold an open file + // descriptor to mLocation. this needs to happen before the + // file can be removed otherwise the Remove call will fail. + if (mSink) { + mSink->Close(); + mSink = nullptr; + } + + nsresult rv = mLocation->Remove(false); + if (NS_FAILED(rv)) NS_ERROR("unable to remove temp file"); + } +} + +NS_IMPL_ISUPPORTS(nsDownloader, nsIDownloader, nsIStreamListener, + nsIRequestObserver) + +NS_IMETHODIMP +nsDownloader::Init(nsIDownloadObserver* observer, nsIFile* location) { + mObserver = observer; + mLocation = location; + return NS_OK; +} + +NS_IMETHODIMP +nsDownloader::OnStartRequest(nsIRequest* request) { + nsresult rv; + if (!mLocation) { + nsCOMPtr<nsIFile> location; + rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(location)); + if (NS_FAILED(rv)) return rv; + + char buf[13]; + NS_MakeRandomString(buf, 8); + memcpy(buf + 8, ".tmp", 5); + rv = location->AppendNative(nsDependentCString(buf, 12)); + if (NS_FAILED(rv)) return rv; + + rv = location->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0600); + if (NS_FAILED(rv)) return rv; + + location.swap(mLocation); + mLocationIsTemp = true; + } + + rv = NS_NewLocalFileOutputStream(getter_AddRefs(mSink), mLocation); + if (NS_FAILED(rv)) return rv; + + // we could wrap this output stream with a buffered output stream, + // but it shouldn't be necessary since we will be writing large + // chunks given to us via OnDataAvailable. + + return NS_OK; +} + +NS_IMETHODIMP +nsDownloader::OnStopRequest(nsIRequest* request, nsresult status) { + if (mSink) { + mSink->Close(); + mSink = nullptr; + } + + mObserver->OnDownloadComplete(this, request, nullptr, status, mLocation); + mObserver = nullptr; + + return NS_OK; +} + +nsresult nsDownloader::ConsumeData(nsIInputStream* in, void* closure, + const char* fromRawSegment, + uint32_t toOffset, uint32_t count, + uint32_t* writeCount) { + nsDownloader* self = (nsDownloader*)closure; + if (self->mSink) return self->mSink->Write(fromRawSegment, count, writeCount); + + *writeCount = count; + return NS_OK; +} + +NS_IMETHODIMP +nsDownloader::OnDataAvailable(nsIRequest* request, nsIInputStream* inStr, + uint64_t sourceOffset, uint32_t count) { + uint32_t n; + return inStr->ReadSegments(ConsumeData, this, count, &n); +} diff --git a/netwerk/base/nsDownloader.h b/netwerk/base/nsDownloader.h new file mode 100644 index 0000000000..1e6879d601 --- /dev/null +++ b/netwerk/base/nsDownloader.h @@ -0,0 +1,36 @@ +/* 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/. */ + +#ifndef nsDownloader_h__ +#define nsDownloader_h__ + +#include "nsIDownloader.h" +#include "nsCOMPtr.h" + +class nsIFile; +class nsIOutputStream; + +class nsDownloader : public nsIDownloader { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIDOWNLOADER + NS_DECL_NSIREQUESTOBSERVER + NS_DECL_NSISTREAMLISTENER + + nsDownloader() : mLocationIsTemp(false) {} + + protected: + virtual ~nsDownloader(); + + static nsresult ConsumeData(nsIInputStream* in, void* closure, + const char* fromRawSegment, uint32_t toOffset, + uint32_t count, uint32_t* writeCount); + + nsCOMPtr<nsIDownloadObserver> mObserver; + nsCOMPtr<nsIFile> mLocation; + nsCOMPtr<nsIOutputStream> mSink; + bool mLocationIsTemp; +}; + +#endif // nsDownloader_h__ diff --git a/netwerk/base/nsFileStreams.cpp b/netwerk/base/nsFileStreams.cpp new file mode 100644 index 0000000000..41526c7642 --- /dev/null +++ b/netwerk/base/nsFileStreams.cpp @@ -0,0 +1,927 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "ipc/IPCMessageUtils.h" + +#if defined(XP_UNIX) || defined(XP_BEOS) +# include <unistd.h> +#elif defined(XP_WIN) +# include <windows.h> +# include "nsILocalFileWin.h" +#else +// XXX add necessary include file for ftruncate (or equivalent) +#endif + +#include "private/pprio.h" +#include "prerror.h" + +#include "IOActivityMonitor.h" +#include "nsFileStreams.h" +#include "nsIFile.h" +#include "nsReadLine.h" +#include "nsIClassInfoImpl.h" +#include "nsLiteralString.h" +#include "nsSocketTransport2.h" // for ErrorAccordingToNSPR() +#include "mozilla/ipc/InputStreamUtils.h" +#include "mozilla/Unused.h" +#include "mozilla/FileUtils.h" +#include "nsNetCID.h" +#include "nsXULAppAPI.h" + +typedef mozilla::ipc::FileDescriptor::PlatformHandleType FileHandleType; + +using namespace mozilla::ipc; +using namespace mozilla::net; + +using mozilla::DebugOnly; +using mozilla::Maybe; +using mozilla::Nothing; +using mozilla::Some; + +//////////////////////////////////////////////////////////////////////////////// +// nsFileStreamBase + +nsFileStreamBase::nsFileStreamBase() + : mFD(nullptr), + mBehaviorFlags(0), + mState(eUnitialized), + mErrorValue(NS_ERROR_FAILURE) {} + +nsFileStreamBase::~nsFileStreamBase() { + // We don't want to try to rewrind the stream when shutting down. + mBehaviorFlags &= ~nsIFileInputStream::REOPEN_ON_REWIND; + + Close(); +} + +NS_IMPL_ISUPPORTS(nsFileStreamBase, nsISeekableStream, nsITellableStream, + nsIFileMetadata) + +NS_IMETHODIMP +nsFileStreamBase::Seek(int32_t whence, int64_t offset) { + nsresult rv = DoPendingOpen(); + NS_ENSURE_SUCCESS(rv, rv); + + int64_t cnt = PR_Seek64(mFD, offset, (PRSeekWhence)whence); + if (cnt == int64_t(-1)) { + return NS_ErrorAccordingToNSPR(); + } + return NS_OK; +} + +NS_IMETHODIMP +nsFileStreamBase::Tell(int64_t* result) { + if (mState == eDeferredOpen && !(mOpenParams.ioFlags & PR_APPEND)) { + *result = 0; + return NS_OK; + } + + nsresult rv = DoPendingOpen(); + NS_ENSURE_SUCCESS(rv, rv); + + int64_t cnt = PR_Seek64(mFD, 0, PR_SEEK_CUR); + if (cnt == int64_t(-1)) { + return NS_ErrorAccordingToNSPR(); + } + *result = cnt; + return NS_OK; +} + +NS_IMETHODIMP +nsFileStreamBase::SetEOF() { + nsresult rv = DoPendingOpen(); + NS_ENSURE_SUCCESS(rv, rv); + +#if defined(XP_UNIX) || defined(XP_BEOS) + // Some system calls require an EOF offset. + int64_t offset; + rv = Tell(&offset); + if (NS_FAILED(rv)) return rv; +#endif + +#if defined(XP_UNIX) || defined(XP_BEOS) + if (ftruncate(PR_FileDesc2NativeHandle(mFD), offset) != 0) { + NS_ERROR("ftruncate failed"); + return NS_ERROR_FAILURE; + } +#elif defined(XP_WIN) + if (!SetEndOfFile((HANDLE)PR_FileDesc2NativeHandle(mFD))) { + NS_ERROR("SetEndOfFile failed"); + return NS_ERROR_FAILURE; + } +#else + // XXX not implemented +#endif + + return NS_OK; +} + +NS_IMETHODIMP +nsFileStreamBase::GetSize(int64_t* _retval) { + nsresult rv = DoPendingOpen(); + NS_ENSURE_SUCCESS(rv, rv); + + PRFileInfo64 info; + if (PR_GetOpenFileInfo64(mFD, &info) == PR_FAILURE) { + return NS_BASE_STREAM_OSERROR; + } + + *_retval = int64_t(info.size); + + return NS_OK; +} + +NS_IMETHODIMP +nsFileStreamBase::GetLastModified(int64_t* _retval) { + nsresult rv = DoPendingOpen(); + NS_ENSURE_SUCCESS(rv, rv); + + PRFileInfo64 info; + if (PR_GetOpenFileInfo64(mFD, &info) == PR_FAILURE) { + return NS_BASE_STREAM_OSERROR; + } + + int64_t modTime = int64_t(info.modifyTime); + if (modTime == 0) { + *_retval = 0; + } else { + *_retval = modTime / int64_t(PR_USEC_PER_MSEC); + } + + return NS_OK; +} + +NS_IMETHODIMP +nsFileStreamBase::GetFileDescriptor(PRFileDesc** _retval) { + nsresult rv = DoPendingOpen(); + NS_ENSURE_SUCCESS(rv, rv); + + *_retval = mFD; + return NS_OK; +} + +nsresult nsFileStreamBase::Close() { + CleanUpOpen(); + + nsresult rv = NS_OK; + if (mFD) { + if (PR_Close(mFD) == PR_FAILURE) rv = NS_BASE_STREAM_OSERROR; + mFD = nullptr; + mState = eClosed; + } + return rv; +} + +nsresult nsFileStreamBase::Available(uint64_t* aResult) { + nsresult rv = DoPendingOpen(); + NS_ENSURE_SUCCESS(rv, rv); + + // PR_Available with files over 4GB returns an error, so we have to + // use the 64-bit version of PR_Available. + int64_t avail = PR_Available64(mFD); + if (avail == -1) { + return NS_ErrorAccordingToNSPR(); + } + + // If available is greater than 4GB, return 4GB + *aResult = (uint64_t)avail; + return NS_OK; +} + +nsresult nsFileStreamBase::Read(char* aBuf, uint32_t aCount, + uint32_t* aResult) { + nsresult rv = DoPendingOpen(); + if (rv == NS_BASE_STREAM_CLOSED) { + *aResult = 0; + return NS_OK; + } + + if (NS_FAILED(rv)) { + return rv; + } + + int32_t bytesRead = PR_Read(mFD, aBuf, aCount); + if (bytesRead == -1) { + return NS_ErrorAccordingToNSPR(); + } + + *aResult = bytesRead; + return NS_OK; +} + +nsresult nsFileStreamBase::ReadSegments(nsWriteSegmentFun aWriter, + void* aClosure, uint32_t aCount, + uint32_t* aResult) { + // ReadSegments is not implemented because it would be inefficient when + // the writer does not consume all data. If you want to call ReadSegments, + // wrap a BufferedInputStream around the file stream. That will call + // Read(). + + return NS_ERROR_NOT_IMPLEMENTED; +} + +nsresult nsFileStreamBase::IsNonBlocking(bool* aNonBlocking) { + *aNonBlocking = false; + return NS_OK; +} + +nsresult nsFileStreamBase::Flush(void) { + nsresult rv = DoPendingOpen(); + NS_ENSURE_SUCCESS(rv, rv); + + int32_t cnt = PR_Sync(mFD); + if (cnt == -1) { + return NS_ErrorAccordingToNSPR(); + } + return NS_OK; +} + +nsresult nsFileStreamBase::Write(const char* buf, uint32_t count, + uint32_t* result) { + nsresult rv = DoPendingOpen(); + NS_ENSURE_SUCCESS(rv, rv); + + int32_t cnt = PR_Write(mFD, buf, count); + if (cnt == -1) { + return NS_ErrorAccordingToNSPR(); + } + *result = cnt; + return NS_OK; +} + +nsresult nsFileStreamBase::WriteFrom(nsIInputStream* inStr, uint32_t count, + uint32_t* _retval) { + MOZ_ASSERT_UNREACHABLE("WriteFrom (see source comment)"); + return NS_ERROR_NOT_IMPLEMENTED; + // File streams intentionally do not support this method. + // If you need something like this, then you should wrap + // the file stream using nsIBufferedOutputStream +} + +nsresult nsFileStreamBase::WriteSegments(nsReadSegmentFun reader, void* closure, + uint32_t count, uint32_t* _retval) { + return NS_ERROR_NOT_IMPLEMENTED; + // File streams intentionally do not support this method. + // If you need something like this, then you should wrap + // the file stream using nsIBufferedOutputStream +} + +nsresult nsFileStreamBase::MaybeOpen(nsIFile* aFile, int32_t aIoFlags, + int32_t aPerm, bool aDeferred) { + NS_ENSURE_STATE(aFile); + + mOpenParams.ioFlags = aIoFlags; + mOpenParams.perm = aPerm; + + if (aDeferred) { + // Clone the file, as it may change between now and the deferred open + nsCOMPtr<nsIFile> file; + nsresult rv = aFile->Clone(getter_AddRefs(file)); + NS_ENSURE_SUCCESS(rv, rv); + + mOpenParams.localFile = std::move(file); + NS_ENSURE_TRUE(mOpenParams.localFile, NS_ERROR_UNEXPECTED); + + mState = eDeferredOpen; + return NS_OK; + } + + mOpenParams.localFile = aFile; + + // Following call open() at main thread. + // Main thread might be blocked, while open a remote file. + return DoOpen(); +} + +void nsFileStreamBase::CleanUpOpen() { mOpenParams.localFile = nullptr; } + +nsresult nsFileStreamBase::DoOpen() { + MOZ_ASSERT(mState == eDeferredOpen || mState == eUnitialized || + mState == eClosed); + NS_ASSERTION(!mFD, "Already have a file descriptor!"); + NS_ASSERTION(mOpenParams.localFile, "Must have a file to open"); + + PRFileDesc* fd; + nsresult rv; + + if (mOpenParams.ioFlags & PR_CREATE_FILE) { + nsCOMPtr<nsIFile> parent; + mOpenParams.localFile->GetParent(getter_AddRefs(parent)); + + // Result doesn't need to be checked. If the file's parent path does not + // exist, make it. If it does exist, do nothing. + if (parent) { + Unused << parent->Create(nsIFile::DIRECTORY_TYPE, 0755); + } + } + +#ifdef XP_WIN + if (mBehaviorFlags & nsIFileInputStream::SHARE_DELETE) { + nsCOMPtr<nsILocalFileWin> file = do_QueryInterface(mOpenParams.localFile); + MOZ_ASSERT(file); + + rv = file->OpenNSPRFileDescShareDelete(mOpenParams.ioFlags, + mOpenParams.perm, &fd); + } else +#endif // XP_WIN + { + rv = mOpenParams.localFile->OpenNSPRFileDesc(mOpenParams.ioFlags, + mOpenParams.perm, &fd); + } + + if (rv == NS_OK && IOActivityMonitor::IsActive()) { + auto nativePath = mOpenParams.localFile->NativePath(); + if (!nativePath.IsEmpty()) { +// registering the file to the activity monitor +#ifdef XP_WIN + // 16 bits unicode + IOActivityMonitor::MonitorFile( + fd, NS_ConvertUTF16toUTF8(nativePath.get()).get()); +#else + // 8 bit unicode + IOActivityMonitor::MonitorFile(fd, nativePath.get()); +#endif + } + } + + CleanUpOpen(); + + if (NS_FAILED(rv)) { + mState = eError; + mErrorValue = rv; + return rv; + } + + mFD = fd; + mState = eOpened; + + return NS_OK; +} + +nsresult nsFileStreamBase::DoPendingOpen() { + switch (mState) { + case eUnitialized: + MOZ_CRASH("This should not happen."); + return NS_ERROR_FAILURE; + + case eDeferredOpen: + return DoOpen(); + + case eOpened: + MOZ_ASSERT(mFD); + if (NS_WARN_IF(!mFD)) { + return NS_ERROR_FAILURE; + } + return NS_OK; + + case eClosed: + MOZ_ASSERT(!mFD); + return NS_BASE_STREAM_CLOSED; + + case eError: + return mErrorValue; + } + + MOZ_CRASH("Invalid mState value."); + return NS_ERROR_FAILURE; +} + +//////////////////////////////////////////////////////////////////////////////// +// nsFileInputStream + +NS_IMPL_ADDREF_INHERITED(nsFileInputStream, nsFileStreamBase) +NS_IMPL_RELEASE_INHERITED(nsFileInputStream, nsFileStreamBase) + +NS_IMPL_CLASSINFO(nsFileInputStream, nullptr, nsIClassInfo::THREADSAFE, + NS_LOCALFILEINPUTSTREAM_CID) + +NS_INTERFACE_MAP_BEGIN(nsFileInputStream) + NS_INTERFACE_MAP_ENTRY(nsIInputStream) + NS_INTERFACE_MAP_ENTRY(nsIFileInputStream) + NS_INTERFACE_MAP_ENTRY(nsILineInputStream) + NS_INTERFACE_MAP_ENTRY(nsIIPCSerializableInputStream) + NS_IMPL_QUERY_CLASSINFO(nsFileInputStream) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsICloneableInputStream, IsCloneable()) +NS_INTERFACE_MAP_END_INHERITING(nsFileStreamBase) + +NS_IMPL_CI_INTERFACE_GETTER(nsFileInputStream, nsIInputStream, + nsIFileInputStream, nsISeekableStream, + nsITellableStream, nsILineInputStream) + +nsresult nsFileInputStream::Create(nsISupports* aOuter, REFNSIID aIID, + void** aResult) { + NS_ENSURE_NO_AGGREGATION(aOuter); + + RefPtr<nsFileInputStream> stream = new nsFileInputStream(); + return stream->QueryInterface(aIID, aResult); +} + +nsresult nsFileInputStream::Open(nsIFile* aFile, int32_t aIOFlags, + int32_t aPerm) { + nsresult rv = NS_OK; + + // If the previous file is open, close it + if (mFD) { + rv = Close(); + if (NS_FAILED(rv)) return rv; + } + + // Open the file + if (aIOFlags == -1) aIOFlags = PR_RDONLY; + if (aPerm == -1) aPerm = 0; + + return MaybeOpen(aFile, aIOFlags, aPerm, + mBehaviorFlags & nsIFileInputStream::DEFER_OPEN); +} + +NS_IMETHODIMP +nsFileInputStream::Init(nsIFile* aFile, int32_t aIOFlags, int32_t aPerm, + int32_t aBehaviorFlags) { + NS_ENSURE_TRUE(!mFD, NS_ERROR_ALREADY_INITIALIZED); + NS_ENSURE_TRUE(mState == eUnitialized || mState == eClosed, + NS_ERROR_ALREADY_INITIALIZED); + + mBehaviorFlags = aBehaviorFlags; + mState = eUnitialized; + + mFile = aFile; + mIOFlags = aIOFlags; + mPerm = aPerm; + + return Open(aFile, aIOFlags, aPerm); +} + +NS_IMETHODIMP +nsFileInputStream::Close() { + // Get the cache position at the time the file was close. This allows + // NS_SEEK_CUR on a closed file that has been opened with + // REOPEN_ON_REWIND. + if (mBehaviorFlags & REOPEN_ON_REWIND) { + // Get actual position. Not one modified by subclasses + nsFileStreamBase::Tell(&mCachedPosition); + } + + // null out mLineBuffer in case Close() is called again after failing + mLineBuffer = nullptr; + return nsFileStreamBase::Close(); +} + +NS_IMETHODIMP +nsFileInputStream::Read(char* aBuf, uint32_t aCount, uint32_t* _retval) { + nsresult rv = nsFileStreamBase::Read(aBuf, aCount, _retval); + if (rv == NS_ERROR_FILE_NOT_FOUND) { + // Don't warn if this is a deffered file not found. + return rv; + } + + NS_ENSURE_SUCCESS(rv, rv); + + // Check if we're at the end of file and need to close + if (mBehaviorFlags & CLOSE_ON_EOF && *_retval == 0) { + Close(); + } + + return NS_OK; +} + +NS_IMETHODIMP +nsFileInputStream::ReadLine(nsACString& aLine, bool* aResult) { + if (!mLineBuffer) { + mLineBuffer = MakeUnique<nsLineBuffer<char>>(); + } + return NS_ReadLine(this, mLineBuffer.get(), aLine, aResult); +} + +NS_IMETHODIMP +nsFileInputStream::Seek(int32_t aWhence, int64_t aOffset) { + return SeekInternal(aWhence, aOffset); +} + +nsresult nsFileInputStream::SeekInternal(int32_t aWhence, int64_t aOffset, + bool aClearBuf) { + nsresult rv = DoPendingOpen(); + if (rv != NS_OK && rv != NS_BASE_STREAM_CLOSED) { + return rv; + } + + if (aClearBuf) { + mLineBuffer = nullptr; + } + + if (rv == NS_BASE_STREAM_CLOSED) { + if (mBehaviorFlags & REOPEN_ON_REWIND) { + rv = Open(mFile, mIOFlags, mPerm); + NS_ENSURE_SUCCESS(rv, rv); + + // If the file was closed, and we do a relative seek, use the + // position we cached when we closed the file to seek to the right + // location. + if (aWhence == NS_SEEK_CUR) { + aWhence = NS_SEEK_SET; + aOffset += mCachedPosition; + } + // If we're trying to seek to the start then we're done, so + // return early to avoid Seek from calling DoPendingOpen and + // opening the underlying file earlier than necessary. + if (aWhence == NS_SEEK_SET && aOffset == 0) { + return NS_OK; + } + } else { + return NS_BASE_STREAM_CLOSED; + } + } + + return nsFileStreamBase::Seek(aWhence, aOffset); +} + +NS_IMETHODIMP +nsFileInputStream::Tell(int64_t* aResult) { + return nsFileStreamBase::Tell(aResult); +} + +NS_IMETHODIMP +nsFileInputStream::Available(uint64_t* aResult) { + return nsFileStreamBase::Available(aResult); +} + +void nsFileInputStream::Serialize(InputStreamParams& aParams, + FileDescriptorArray& aFileDescriptors, + bool aDelayedStart, uint32_t aMaxSize, + uint32_t* aSizeUsed, + ParentToChildStreamActorManager* aManager) { + MOZ_ASSERT(aSizeUsed); + *aSizeUsed = 0; + + SerializeInternal(aParams, aFileDescriptors); +} + +void nsFileInputStream::Serialize(InputStreamParams& aParams, + FileDescriptorArray& aFileDescriptors, + bool aDelayedStart, uint32_t aMaxSize, + uint32_t* aSizeUsed, + ChildToParentStreamActorManager* aManager) { + MOZ_ASSERT(aSizeUsed); + *aSizeUsed = 0; + + SerializeInternal(aParams, aFileDescriptors); +} + +void nsFileInputStream::SerializeInternal( + InputStreamParams& aParams, FileDescriptorArray& aFileDescriptors) { + FileInputStreamParams params; + + if (NS_SUCCEEDED(DoPendingOpen())) { + MOZ_ASSERT(mFD); + FileHandleType fd = FileHandleType(PR_FileDesc2NativeHandle(mFD)); + NS_ASSERTION(fd, "This should never be null!"); + + DebugOnly dbgFD = aFileDescriptors.AppendElement(fd); + NS_ASSERTION(dbgFD->IsValid(), "Sending an invalid file descriptor!"); + + params.fileDescriptorIndex() = aFileDescriptors.Length() - 1; + + Close(); + } else { + NS_WARNING( + "This file has not been opened (or could not be opened). " + "Sending an invalid file descriptor to the other process!"); + + params.fileDescriptorIndex() = UINT32_MAX; + } + + int32_t behaviorFlags = mBehaviorFlags; + + // The receiving process (or thread) is going to have an open file + // descriptor automatically so transferring this flag is meaningless. + behaviorFlags &= ~nsIFileInputStream::DEFER_OPEN; + + params.behaviorFlags() = behaviorFlags; + params.ioFlags() = mIOFlags; + + aParams = params; +} + +bool nsFileInputStream::Deserialize( + const InputStreamParams& aParams, + const FileDescriptorArray& aFileDescriptors) { + NS_ASSERTION(!mFD, "Already have a file descriptor?!"); + NS_ASSERTION(mState == nsFileStreamBase::eUnitialized, "Deferring open?!"); + NS_ASSERTION(!mFile, "Should never have a file here!"); + NS_ASSERTION(!mPerm, "This should always be 0!"); + + if (aParams.type() != InputStreamParams::TFileInputStreamParams) { + NS_WARNING("Received unknown parameters from the other process!"); + return false; + } + + const FileInputStreamParams& params = aParams.get_FileInputStreamParams(); + + uint32_t fileDescriptorIndex = params.fileDescriptorIndex(); + + FileDescriptor fd; + if (fileDescriptorIndex < aFileDescriptors.Length()) { + fd = aFileDescriptors[fileDescriptorIndex]; + NS_WARNING_ASSERTION(fd.IsValid(), "Received an invalid file descriptor!"); + } else { + NS_WARNING("Received a bad file descriptor index!"); + } + + if (fd.IsValid()) { + auto rawFD = fd.ClonePlatformHandle(); + PRFileDesc* fileDesc = PR_ImportFile(PROsfd(rawFD.release())); + if (!fileDesc) { + NS_WARNING("Failed to import file handle!"); + return false; + } + mFD = fileDesc; + mState = eOpened; + } else { + mState = eError; + mErrorValue = NS_ERROR_FILE_NOT_FOUND; + } + + mBehaviorFlags = params.behaviorFlags(); + + if (!XRE_IsParentProcess()) { + // A child process shouldn't close when it reads the end because it will + // not be able to reopen the file later. + mBehaviorFlags &= ~nsIFileInputStream::CLOSE_ON_EOF; + + // A child process will not be able to reopen the file so this flag is + // meaningless. + mBehaviorFlags &= ~nsIFileInputStream::REOPEN_ON_REWIND; + } + + mIOFlags = params.ioFlags(); + + return true; +} + +bool nsFileInputStream::IsCloneable() const { + // This inputStream is cloneable only if has been created using Init() and + // it owns a nsIFile. This is not true when it is deserialized from IPC. + return XRE_IsParentProcess() && mFile; +} + +NS_IMETHODIMP +nsFileInputStream::GetCloneable(bool* aCloneable) { + *aCloneable = IsCloneable(); + return NS_OK; +} + +NS_IMETHODIMP +nsFileInputStream::Clone(nsIInputStream** aResult) { + MOZ_ASSERT(IsCloneable()); + return NS_NewLocalFileInputStream(aResult, mFile, mIOFlags, mPerm, + mBehaviorFlags); +} + +//////////////////////////////////////////////////////////////////////////////// +// nsFileOutputStream + +NS_IMPL_ISUPPORTS_INHERITED(nsFileOutputStream, nsFileStreamBase, + nsIOutputStream, nsIFileOutputStream) + +nsresult nsFileOutputStream::Create(nsISupports* aOuter, REFNSIID aIID, + void** aResult) { + NS_ENSURE_NO_AGGREGATION(aOuter); + + RefPtr<nsFileOutputStream> stream = new nsFileOutputStream(); + return stream->QueryInterface(aIID, aResult); +} + +NS_IMETHODIMP +nsFileOutputStream::Init(nsIFile* file, int32_t ioFlags, int32_t perm, + int32_t behaviorFlags) { + NS_ENSURE_TRUE(mFD == nullptr, NS_ERROR_ALREADY_INITIALIZED); + NS_ENSURE_TRUE(mState == eUnitialized || mState == eClosed, + NS_ERROR_ALREADY_INITIALIZED); + + mBehaviorFlags = behaviorFlags; + mState = eUnitialized; + + if (ioFlags == -1) ioFlags = PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE; + if (perm <= 0) perm = 0664; + + return MaybeOpen(file, ioFlags, perm, + mBehaviorFlags & nsIFileOutputStream::DEFER_OPEN); +} + +nsresult nsFileOutputStream::InitWithFileDescriptor( + const mozilla::ipc::FileDescriptor& aFd) { + NS_ENSURE_TRUE(mFD == nullptr, NS_ERROR_ALREADY_INITIALIZED); + NS_ENSURE_TRUE(mState == eUnitialized || mState == eClosed, + NS_ERROR_ALREADY_INITIALIZED); + + if (aFd.IsValid()) { + auto rawFD = aFd.ClonePlatformHandle(); + PRFileDesc* fileDesc = PR_ImportFile(PROsfd(rawFD.release())); + if (!fileDesc) { + NS_WARNING("Failed to import file handle!"); + return NS_ERROR_FAILURE; + } + mFD = fileDesc; + mState = eOpened; + } else { + mState = eError; + mErrorValue = NS_ERROR_FILE_NOT_FOUND; + } + + return NS_OK; +} + +NS_IMETHODIMP +nsFileOutputStream::Preallocate(int64_t aLength) { + if (!mFD) { + return NS_ERROR_NOT_INITIALIZED; + } + + if (!mozilla::fallocate(mFD, aLength)) { + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +//////////////////////////////////////////////////////////////////////////////// +// nsAtomicFileOutputStream + +NS_IMPL_ISUPPORTS_INHERITED(nsAtomicFileOutputStream, nsFileOutputStream, + nsISafeOutputStream, nsIOutputStream, + nsIFileOutputStream) + +NS_IMETHODIMP +nsAtomicFileOutputStream::Init(nsIFile* file, int32_t ioFlags, int32_t perm, + int32_t behaviorFlags) { + // While `PR_APPEND` is not supported, `-1` is used as `ioFlags` parameter + // in some places, and `PR_APPEND | PR_TRUNCATE` does not require appending + // to existing file. So, throw an exception only if `PR_APPEND` is + // explicitly specified without `PR_TRUNCATE`. + if ((ioFlags & PR_APPEND) && !(ioFlags & PR_TRUNCATE)) { + return NS_ERROR_INVALID_ARG; + } + return nsFileOutputStream::Init(file, ioFlags, perm, behaviorFlags); +} + +nsresult nsAtomicFileOutputStream::DoOpen() { + // Make sure mOpenParams.localFile will be empty if we bail somewhere in + // this function + nsCOMPtr<nsIFile> file; + file.swap(mOpenParams.localFile); + + if (!file) { + return NS_ERROR_NOT_INITIALIZED; + } + nsresult rv = file->Exists(&mTargetFileExists); + if (NS_FAILED(rv)) { + NS_ERROR("Can't tell if target file exists"); + mTargetFileExists = + true; // Safer to assume it exists - we just do more work. + } + + // follow symlinks, for two reasons: + // 1) if a user has deliberately set up a profile file as a symlink, we + // honor it + // 2) to make the MoveToNative() in Finish() an atomic operation (which may + // not be the case if moving across directories on different + // filesystems). + nsCOMPtr<nsIFile> tempResult; + rv = file->Clone(getter_AddRefs(tempResult)); + if (NS_SUCCEEDED(rv) && mTargetFileExists) { + tempResult->Normalize(); + } + + if (NS_SUCCEEDED(rv) && mTargetFileExists) { + // Abort if |file| is not writable; it won't work as an output stream. + bool isWritable; + if (NS_SUCCEEDED(file->IsWritable(&isWritable)) && !isWritable) { + return NS_ERROR_FILE_ACCESS_DENIED; + } + + uint32_t origPerm; + if (NS_FAILED(file->GetPermissions(&origPerm))) { + NS_ERROR("Can't get permissions of target file"); + origPerm = mOpenParams.perm; + } + + // XXX What if |perm| is more restrictive then |origPerm|? + // This leaves the user supplied permissions as they were. + rv = tempResult->CreateUnique(nsIFile::NORMAL_FILE_TYPE, origPerm); + } + if (NS_SUCCEEDED(rv)) { + // nsFileOutputStream::DoOpen will work on the temporary file, so we + // prepare it and place it in mOpenParams.localFile. + mOpenParams.localFile = tempResult; + mTempFile = tempResult; + mTargetFile = file; + rv = nsFileOutputStream::DoOpen(); + } + return rv; +} + +NS_IMETHODIMP +nsAtomicFileOutputStream::Close() { + nsresult rv = nsFileOutputStream::Close(); + + // the consumer doesn't want the original file overwritten - + // so clean up by removing the temp file. + if (mTempFile) { + mTempFile->Remove(false); + mTempFile = nullptr; + } + + return rv; +} + +NS_IMETHODIMP +nsAtomicFileOutputStream::Finish() { + nsresult rv = nsFileOutputStream::Close(); + + // if there is no temp file, don't try to move it over the original target. + // It would destroy the targetfile if close() is called twice. + if (!mTempFile) return rv; + + // Only overwrite if everything was ok, and the temp file could be closed. + if (NS_SUCCEEDED(mWriteResult) && NS_SUCCEEDED(rv)) { + NS_ENSURE_STATE(mTargetFile); + + if (!mTargetFileExists) { + // If the target file did not exist when we were initialized, then the + // temp file we gave out was actually a reference to the target file. + // since we succeeded in writing to the temp file (and hence succeeded + // in writing to the target file), there is nothing more to do. +#ifdef DEBUG + bool equal; + if (NS_FAILED(mTargetFile->Equals(mTempFile, &equal)) || !equal) + NS_WARNING("mTempFile not equal to mTargetFile"); +#endif + } else { + nsAutoString targetFilename; + rv = mTargetFile->GetLeafName(targetFilename); + if (NS_SUCCEEDED(rv)) { + // This will replace target. + rv = mTempFile->MoveTo(nullptr, targetFilename); + if (NS_FAILED(rv)) mTempFile->Remove(false); + } + } + } else { + mTempFile->Remove(false); + + // if writing failed, propagate the failure code to the caller. + if (NS_FAILED(mWriteResult)) rv = mWriteResult; + } + mTempFile = nullptr; + return rv; +} + +NS_IMETHODIMP +nsAtomicFileOutputStream::Write(const char* buf, uint32_t count, + uint32_t* result) { + nsresult rv = nsFileOutputStream::Write(buf, count, result); + if (NS_SUCCEEDED(mWriteResult)) { + if (NS_FAILED(rv)) + mWriteResult = rv; + else if (count != *result) + mWriteResult = NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; + + if (NS_FAILED(mWriteResult) && count > 0) + NS_WARNING("writing to output stream failed! data may be lost"); + } + return rv; +} + +//////////////////////////////////////////////////////////////////////////////// +// nsSafeFileOutputStream + +NS_IMETHODIMP +nsSafeFileOutputStream::Finish() { + (void)Flush(); + return nsAtomicFileOutputStream::Finish(); +} + +//////////////////////////////////////////////////////////////////////////////// +// nsFileStream + +NS_IMPL_ISUPPORTS_INHERITED(nsFileStream, nsFileStreamBase, nsIInputStream, + nsIOutputStream, nsIFileStream) + +NS_IMETHODIMP +nsFileStream::Init(nsIFile* file, int32_t ioFlags, int32_t perm, + int32_t behaviorFlags) { + NS_ENSURE_TRUE(mFD == nullptr, NS_ERROR_ALREADY_INITIALIZED); + NS_ENSURE_TRUE(mState == eUnitialized || mState == eClosed, + NS_ERROR_ALREADY_INITIALIZED); + + mBehaviorFlags = behaviorFlags; + mState = eUnitialized; + + if (ioFlags == -1) ioFlags = PR_RDWR; + if (perm <= 0) perm = 0; + + return MaybeOpen(file, ioFlags, perm, + mBehaviorFlags & nsIFileStream::DEFER_OPEN); +} + +//////////////////////////////////////////////////////////////////////////////// diff --git a/netwerk/base/nsFileStreams.h b/netwerk/base/nsFileStreams.h new file mode 100644 index 0000000000..c694d1b366 --- /dev/null +++ b/netwerk/base/nsFileStreams.h @@ -0,0 +1,288 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef nsFileStreams_h__ +#define nsFileStreams_h__ + +#include "mozilla/UniquePtr.h" +#include "nsIFileStreams.h" +#include "nsIFile.h" +#include "nsICloneableInputStream.h" +#include "nsIInputStream.h" +#include "nsIOutputStream.h" +#include "nsISafeOutputStream.h" +#include "nsISeekableStream.h" +#include "nsILineInputStream.h" +#include "nsCOMPtr.h" +#include "nsIIPCSerializableInputStream.h" +#include "nsReadLine.h" +#include <algorithm> + +namespace mozilla { +namespace ipc { +class FileDescriptor; +} // namespace ipc +} // namespace mozilla + +//////////////////////////////////////////////////////////////////////////////// + +class nsFileStreamBase : public nsISeekableStream, public nsIFileMetadata { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSISEEKABLESTREAM + NS_DECL_NSITELLABLESTREAM + NS_DECL_NSIFILEMETADATA + + nsFileStreamBase(); + + protected: + virtual ~nsFileStreamBase(); + + nsresult Close(); + nsresult Available(uint64_t* _retval); + nsresult Read(char* aBuf, uint32_t aCount, uint32_t* _retval); + nsresult ReadSegments(nsWriteSegmentFun aWriter, void* aClosure, + uint32_t aCount, uint32_t* _retval); + nsresult IsNonBlocking(bool* _retval); + nsresult Flush(); + nsresult Write(const char* aBuf, uint32_t aCount, uint32_t* _retval); + nsresult WriteFrom(nsIInputStream* aFromStream, uint32_t aCount, + uint32_t* _retval); + nsresult WriteSegments(nsReadSegmentFun aReader, void* aClosure, + uint32_t aCount, uint32_t* _retval); + + PRFileDesc* mFD; + + /** + * Flags describing our behavior. See the IDL file for possible values. + */ + int32_t mBehaviorFlags; + + enum { + // This is the default value. It will be changed by Deserialize or Init. + eUnitialized, + // The opening has been deferred. See DEFER_OPEN. + eDeferredOpen, + // The file has been opened. mFD is not null. + eOpened, + // The file has been closed. mFD is null. + eClosed, + // Something bad happen in the Open() or in Deserialize(). The actual + // error value is stored in mErrorValue. + eError + } mState; + + struct OpenParams { + nsCOMPtr<nsIFile> localFile; + int32_t ioFlags; + int32_t perm; + }; + + /** + * Data we need to do an open. + */ + OpenParams mOpenParams; + + nsresult mErrorValue; + + /** + * Prepares the data we need to open the file, and either does the open now + * by calling DoOpen(), or leaves it to be opened later by a call to + * DoPendingOpen(). + */ + nsresult MaybeOpen(nsIFile* aFile, int32_t aIoFlags, int32_t aPerm, + bool aDeferred); + + /** + * Cleans up data prepared in MaybeOpen. + */ + void CleanUpOpen(); + + /** + * Open the file. This is called either from MaybeOpen (during Init) + * or from DoPendingOpen (if DEFER_OPEN is used when initializing this + * stream). The default behavior of DoOpen is to open the file and save the + * file descriptor. + */ + virtual nsresult DoOpen(); + + /** + * Based on mState, this method does the opening, return an error, or do + * nothing. If the return value is not NS_OK, please, return it back to the + * callee. + */ + inline nsresult DoPendingOpen(); +}; + +//////////////////////////////////////////////////////////////////////////////// + +// nsFileInputStream is cloneable only on the parent process because only there +// it can open the same file multiple times. + +class nsFileInputStream : public nsFileStreamBase, + public nsIFileInputStream, + public nsILineInputStream, + public nsIIPCSerializableInputStream, + public nsICloneableInputStream { + public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_NSIFILEINPUTSTREAM + NS_DECL_NSILINEINPUTSTREAM + NS_DECL_NSIIPCSERIALIZABLEINPUTSTREAM + NS_DECL_NSICLONEABLEINPUTSTREAM + + NS_IMETHOD Close() override; + NS_IMETHOD Tell(int64_t* aResult) override; + NS_IMETHOD Available(uint64_t* _retval) override; + NS_IMETHOD Read(char* aBuf, uint32_t aCount, uint32_t* _retval) override; + NS_IMETHOD ReadSegments(nsWriteSegmentFun aWriter, void* aClosure, + uint32_t aCount, uint32_t* _retval) override { + return nsFileStreamBase::ReadSegments(aWriter, aClosure, aCount, _retval); + } + NS_IMETHOD IsNonBlocking(bool* _retval) override { + return nsFileStreamBase::IsNonBlocking(_retval); + } + + // Overrided from nsFileStreamBase + NS_IMETHOD Seek(int32_t aWhence, int64_t aOffset) override; + + nsFileInputStream() + : mLineBuffer(nullptr), mIOFlags(0), mPerm(0), mCachedPosition(0) {} + + static nsresult Create(nsISupports* aOuter, REFNSIID aIID, void** aResult); + + protected: + virtual ~nsFileInputStream() = default; + + void SerializeInternal(mozilla::ipc::InputStreamParams& aParams, + FileDescriptorArray& aFileDescriptors); + + nsresult SeekInternal(int32_t aWhence, int64_t aOffset, + bool aClearBuf = true); + + mozilla::UniquePtr<nsLineBuffer<char>> mLineBuffer; + + /** + * The file being opened. + */ + nsCOMPtr<nsIFile> mFile; + /** + * The IO flags passed to Init() for the file open. + */ + int32_t mIOFlags; + /** + * The permissions passed to Init() for the file open. + */ + int32_t mPerm; + + /** + * Cached position for Tell for automatically reopening streams. + */ + int64_t mCachedPosition; + + protected: + /** + * Internal, called to open a file. Parameters are the same as their + * Init() analogues. + */ + nsresult Open(nsIFile* file, int32_t ioFlags, int32_t perm); + + bool IsCloneable() const; +}; + +//////////////////////////////////////////////////////////////////////////////// + +class nsFileOutputStream : public nsFileStreamBase, public nsIFileOutputStream { + public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_NSIFILEOUTPUTSTREAM + NS_FORWARD_NSIOUTPUTSTREAM(nsFileStreamBase::) + + static nsresult Create(nsISupports* aOuter, REFNSIID aIID, void** aResult); + nsresult InitWithFileDescriptor(const mozilla::ipc::FileDescriptor& aFd); + + protected: + virtual ~nsFileOutputStream() = default; +}; + +//////////////////////////////////////////////////////////////////////////////// + +/** + * A safe file output stream that overwrites the destination file only + * once writing is complete. This protects against incomplete writes + * due to the process or the thread being interrupted or crashed. + */ +class nsAtomicFileOutputStream : public nsFileOutputStream, + public nsISafeOutputStream { + public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_NSISAFEOUTPUTSTREAM + + nsAtomicFileOutputStream() : mTargetFileExists(true), mWriteResult(NS_OK) {} + + virtual nsresult DoOpen() override; + + NS_IMETHOD Close() override; + NS_IMETHOD Write(const char* buf, uint32_t count, uint32_t* result) override; + NS_IMETHOD Init(nsIFile* file, int32_t ioFlags, int32_t perm, + int32_t behaviorFlags) override; + + protected: + virtual ~nsAtomicFileOutputStream() = default; + + nsCOMPtr<nsIFile> mTargetFile; + nsCOMPtr<nsIFile> mTempFile; + + bool mTargetFileExists; + nsresult mWriteResult; // Internally set in Write() +}; + +//////////////////////////////////////////////////////////////////////////////// + +/** + * A safe file output stream that overwrites the destination file only + * once writing + flushing is complete. This protects against more + * classes of software/hardware errors than nsAtomicFileOutputStream, + * at the expense of being more costly to the disk, OS and battery. + */ +class nsSafeFileOutputStream : public nsAtomicFileOutputStream { + public: + NS_IMETHOD Finish() override; +}; + +//////////////////////////////////////////////////////////////////////////////// + +class nsFileStream : public nsFileStreamBase, + public nsIInputStream, + public nsIOutputStream, + public nsIFileStream { + public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_NSIFILESTREAM + NS_FORWARD_NSIINPUTSTREAM(nsFileStreamBase::) + + // Can't use NS_FORWARD_NSIOUTPUTSTREAM due to overlapping methods + // Close() and IsNonBlocking() + NS_IMETHOD Flush() override { return nsFileStreamBase::Flush(); } + NS_IMETHOD Write(const char* aBuf, uint32_t aCount, + uint32_t* _retval) override { + return nsFileStreamBase::Write(aBuf, aCount, _retval); + } + NS_IMETHOD WriteFrom(nsIInputStream* aFromStream, uint32_t aCount, + uint32_t* _retval) override { + return nsFileStreamBase::WriteFrom(aFromStream, aCount, _retval); + } + NS_IMETHOD WriteSegments(nsReadSegmentFun aReader, void* aClosure, + uint32_t aCount, uint32_t* _retval) override { + return nsFileStreamBase::WriteSegments(aReader, aClosure, aCount, _retval); + } + + protected: + virtual ~nsFileStream() = default; +}; + +//////////////////////////////////////////////////////////////////////////////// + +#endif // nsFileStreams_h__ diff --git a/netwerk/base/nsIApplicationCache.idl b/netwerk/base/nsIApplicationCache.idl new file mode 100644 index 0000000000..2f4d789041 --- /dev/null +++ b/netwerk/base/nsIApplicationCache.idl @@ -0,0 +1,203 @@ +/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * 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 "nsISupports.idl" + +interface nsIArray; +interface nsIFile; +interface nsIURI; + +/** + * Application caches can store a set of namespace entries that affect + * loads from the application cache. If a load from the cache fails + * to match an exact cache entry, namespaces entries will be searched + * for a substring match, and should be applied appropriately. + */ +[scriptable, uuid(96e4c264-2065-4ce9-93bb-43734c62c4eb)] +interface nsIApplicationCacheNamespace : nsISupports +{ + /** + * Items matching this namespace can be fetched from the network + * when loading from this cache. The "data" attribute is unused. + */ + const unsigned long NAMESPACE_BYPASS = 1 << 0; + + /** + * Items matching this namespace can be fetched from the network + * when loading from this cache. If the load fails, the cache entry + * specified by the "data" attribute should be loaded instead. + */ + const unsigned long NAMESPACE_FALLBACK = 1 << 1; + + /** + * Items matching this namespace should be cached + * opportunistically. Successful toplevel loads of documents + * in this namespace should be placed in the application cache. + * Namespaces specifying NAMESPACE_OPPORTUNISTIC may also specify + * NAMESPACE_FALLBACK to supply a fallback entry. + */ + const unsigned long NAMESPACE_OPPORTUNISTIC = 1 << 2; + + /** + * Initialize the namespace. + */ + void init(in unsigned long itemType, + in ACString namespaceSpec, + in ACString data); + + /** + * The namespace type. + */ + readonly attribute unsigned long itemType; + + /** + * The prefix of this namespace. This should be the asciiSpec of the + * URI prefix. + */ + readonly attribute ACString namespaceSpec; + + /** + * Data associated with this namespace, such as a fallback. URI data should + * use the asciiSpec of the URI. + */ + readonly attribute ACString data; +}; + +/** + * Application caches store resources for offline use. Each + * application cache has a unique client ID for use with + * nsICacheService::openSession() to access the cache's entries. + * + * Each entry in the application cache can be marked with a set of + * types, as discussed in the WHAT-WG offline applications + * specification. + * + * All application caches with the same group ID belong to a cache + * group. Each group has one "active" cache that will service future + * loads. Inactive caches will be removed from the cache when they are + * no longer referenced. + */ +[scriptable, uuid(06568DAE-C374-4383-A122-0CC96C7177F2)] +interface nsIApplicationCache : nsISupports +{ + /** + * Init this application cache instance to just hold the group ID and + * the client ID to work just as a handle to the real cache. Used on + * content process to simplify the application cache code. + */ + void initAsHandle(in ACString groupId, in ACString clientId); + + /** + * Entries in an application cache can be marked as one or more of + * the following types. + */ + + /* This item is the application manifest. */ + const unsigned long ITEM_MANIFEST = 1 << 0; + + /* This item was explicitly listed in the application manifest. */ + const unsigned long ITEM_EXPLICIT = 1 << 1; + + /* This item was navigated in a toplevel browsing context, and + * named this cache's group as its manifest. */ + const unsigned long ITEM_IMPLICIT = 1 << 2; + + /* This item was added by the dynamic scripting API */ + const unsigned long ITEM_DYNAMIC = 1 << 3; + + /* This item was listed in the application manifest, but named a + * different cache group as its manifest. */ + const unsigned long ITEM_FOREIGN = 1 << 4; + + /* This item was listed as a fallback entry. */ + const unsigned long ITEM_FALLBACK = 1 << 5; + + /* This item matched an opportunistic cache namespace and was + * cached accordingly. */ + const unsigned long ITEM_OPPORTUNISTIC = 1 << 6; + + /** + * URI of the manfiest specifying this application cache. + **/ + readonly attribute nsIURI manifestURI; + + /** + * The group ID for this cache group. It is an internally generated string + * and cannot be used as manifest URL spec. + **/ + readonly attribute ACString groupID; + + /** + * The client ID for this application cache. Clients can open a + * session with nsICacheService::createSession() using this client + * ID and a storage policy of STORE_OFFLINE to access this cache. + */ + readonly attribute ACString clientID; + + /** + * TRUE if the cache is the active cache for this group. + */ + readonly attribute boolean active; + + /** + * The disk usage of the application cache, in bytes. + */ + readonly attribute unsigned long usage; + + /** + * Makes this cache the active application cache for this group. + * Future loads associated with this group will come from this + * cache. Other caches from this cache group will be deactivated. + */ + void activate(); + + /** + * Discard this application cache. Removes all cached resources + * for this cache. If this is the active application cache for the + * group, the group will be removed. + */ + void discard(); + + /** + * Adds item types to a given entry. + */ + void markEntry(in ACString key, in unsigned long typeBits); + + /** + * Removes types from a given entry. If the resulting entry has + * no types left, the entry is removed. + */ + void unmarkEntry(in ACString key, in unsigned long typeBits); + + /** + * Gets the types for a given entry. + */ + unsigned long getTypes(in ACString key); + + /** + * Returns any entries in the application cache whose type matches + * one or more of the bits in typeBits. + */ + Array<ACString> gatherEntries(in uint32_t typeBits); + + /** + * Add a set of namespace entries to the application cache. + * @param namespaces + * An nsIArray of nsIApplicationCacheNamespace entries. + */ + void addNamespaces(in nsIArray namespaces); + + /** + * Get the most specific namespace matching a given key. + */ + nsIApplicationCacheNamespace getMatchingNamespace(in ACString key); + + /** + * If set, this offline cache is placed in a different directory + * than the current application profile. + */ + readonly attribute nsIFile profileDirectory; +}; diff --git a/netwerk/base/nsIApplicationCacheChannel.idl b/netwerk/base/nsIApplicationCacheChannel.idl new file mode 100644 index 0000000000..410e2946d8 --- /dev/null +++ b/netwerk/base/nsIApplicationCacheChannel.idl @@ -0,0 +1,57 @@ +/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * 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 "nsIApplicationCacheContainer.idl" + +/** + * Interface implemented by channels that support application caches. + */ +[scriptable, uuid(6FA816B1-6D5F-4380-9704-054D0908CFA3)] +interface nsIApplicationCacheChannel : nsIApplicationCacheContainer +{ + /** + * TRUE when the resource came from the application cache. This + * might be false even there is assigned an application cache + * e.g. in case of fallback of load of an entry matching bypass + * namespace. + */ + readonly attribute boolean loadedFromApplicationCache; + + /** + * When true, the channel will ask its notification callbacks for + * an application cache if one is not explicitly provided. Default + * value is true. + * + * NS_ERROR_ALREADY_OPENED will be thrown if set after AsyncOpen() + * is called. + */ + attribute boolean inheritApplicationCache; + + /** + * When true, the channel will choose an application cache if one + * was not explicitly provided and none is available from the + * notification callbacks. Default value is false. + * + * This attribute will not be transferred through a redirect. + * + * NS_ERROR_ALREADY_OPENED will be thrown if set after AsyncOpen() + * is called. + */ + attribute boolean chooseApplicationCache; + + /** + * A shortcut method to mark the cache item of this channel as 'foreign'. + * See the 'cache selection algorithm' and CACHE_SELECTION_RELOAD + * action handling in nsContentSink. + */ + void markOfflineCacheEntryAsForeign(); + + /** + * Set offline application cache object to instruct the channel + * to cache for offline use using this application cache. + */ + attribute nsIApplicationCache applicationCacheForWrite; +}; diff --git a/netwerk/base/nsIApplicationCacheContainer.idl b/netwerk/base/nsIApplicationCacheContainer.idl new file mode 100644 index 0000000000..af0b74cbee --- /dev/null +++ b/netwerk/base/nsIApplicationCacheContainer.idl @@ -0,0 +1,19 @@ +/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * 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 "nsISupports.idl" + +interface nsIApplicationCache; + +/** + * Interface used by objects that can be associated with an + * application cache. + */ +[scriptable, uuid(bbb80700-1f7f-4258-aff4-1743cc5a7d23)] +interface nsIApplicationCacheContainer : nsISupports +{ + attribute nsIApplicationCache applicationCache; +}; diff --git a/netwerk/base/nsIApplicationCacheService.idl b/netwerk/base/nsIApplicationCacheService.idl new file mode 100644 index 0000000000..4c683e874a --- /dev/null +++ b/netwerk/base/nsIApplicationCacheService.idl @@ -0,0 +1,108 @@ +/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * 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 "nsISupports.idl" + +interface nsIApplicationCache; +interface nsIFile; +interface nsIURI; +interface nsILoadContextInfo; + +/** + * The application cache service manages the set of application cache + * groups. + */ +[scriptable, uuid(b8b6546c-6cec-4bda-82df-08e006a97b56)] +interface nsIApplicationCacheService : nsISupports +{ + /** + * Create group string identifying cache group according the manifest + * URL and the given principal. + */ + ACString buildGroupIDForInfo(in nsIURI aManifestURL, + in nsILoadContextInfo aLoadContextInfo); + ACString buildGroupIDForSuffix(in nsIURI aManifestURL, + in ACString aOriginSuffix); + + /** + * Create a new, empty application cache for the given cache + * group. + */ + nsIApplicationCache createApplicationCache(in ACString group); + + /** + * Create a new, empty application cache for the given cache + * group residing in a custom directory with a custom quota. + * + * @param group + * URL of the manifest + * @param directory + * Actually a reference to a profile directory where to + * create the OfflineCache sub-dir. + * @param quota + * Optional override of the default quota. + */ + nsIApplicationCache createCustomApplicationCache(in ACString group, + in nsIFile profileDir, + in int32_t quota); + + /** + * Get an application cache object for the given client ID. + */ + nsIApplicationCache getApplicationCache(in ACString clientID); + + /** + * Get the currently active cache object for a cache group. + */ + nsIApplicationCache getActiveCache(in ACString group); + + /** + * Deactivate the currently-active cache object for a cache group. + */ + void deactivateGroup(in ACString group); + + /** + * Evict offline cache entries, either all of them or those belonging + * to the given origin. + */ + void evict(in nsILoadContextInfo aLoadContextInfo); + + /** + * Delete caches whom origin attributes matches the given pattern. + */ + void evictMatchingOriginAttributes(in AString aPattern); + + /** + * Try to find the best application cache to serve a resource. + */ + nsIApplicationCache chooseApplicationCache(in ACString key, + [optional] in nsILoadContextInfo aLoadContextInfo); + + /** + * Flags the key as being opportunistically cached. + * + * This method should also propagate the entry to other + * application caches with the same opportunistic namespace, but + * this is not currently implemented. + * + * @param cache + * The cache in which the entry is cached now. + * @param key + * The cache entry key. + */ + void cacheOpportunistically(in nsIApplicationCache cache, in ACString key); + + /** + * Get the list of application cache groups. + */ + Array<ACString> getGroups(); + + /** + * Get the list of application cache groups in the order of + * activating time. + */ + Array<ACString> getGroupsTimeOrdered(); +}; diff --git a/netwerk/base/nsIArrayBufferInputStream.idl b/netwerk/base/nsIArrayBufferInputStream.idl new file mode 100644 index 0000000000..f11135b246 --- /dev/null +++ b/netwerk/base/nsIArrayBufferInputStream.idl @@ -0,0 +1,25 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "nsIInputStream.idl" + +/** + * nsIArrayBufferInputStream + * + * Provides scriptable methods for initializing a nsIInputStream + * implementation with an ArrayBuffer. + */ +[scriptable, uuid(3014dde6-aa1c-41db-87d0-48764a3710f6)] +interface nsIArrayBufferInputStream : nsIInputStream +{ + /** + * SetData - assign an ArrayBuffer to the input stream. + * + * @param buffer - stream data + * @param byteOffset - stream data offset + * @param byteLen - stream data length + */ + void setData(in jsval buffer, in unsigned long byteOffset, in unsigned long byteLen); +}; diff --git a/netwerk/base/nsIAsyncStreamCopier.idl b/netwerk/base/nsIAsyncStreamCopier.idl new file mode 100644 index 0000000000..633fe72b6e --- /dev/null +++ b/netwerk/base/nsIAsyncStreamCopier.idl @@ -0,0 +1,64 @@ +/* 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 "nsIRequest.idl" + +interface nsIInputStream; +interface nsIOutputStream; +interface nsIRequestObserver; +interface nsIEventTarget; + +// You should prefer nsIAsyncStreamCopier2 +[scriptable, uuid(5a19ca27-e041-4aca-8287-eb248d4c50c0)] +interface nsIAsyncStreamCopier : nsIRequest +{ + /** + * Initialize the stream copier. + * + * @param aSource + * contains the data to be copied. + * @param aSink + * specifies the destination for the data. + * @param aTarget + * specifies the thread on which the copy will occur. a null value + * is permitted and will cause the copy to occur on an unspecified + * background thread. + * @param aSourceBuffered + * true if aSource implements ReadSegments. + * @param aSinkBuffered + * true if aSink implements WriteSegments. + * @param aChunkSize + * specifies how many bytes to read/write at a time. this controls + * the granularity of the copying. it should match the segment size + * of the "buffered" streams involved. + * @param aCloseSource + * true if aSource should be closed after copying. + * @param aCloseSink + * true if aSink should be closed after copying. + * + * NOTE: at least one of the streams must be buffered. If you do not know + * whether your streams are buffered, you should use nsIAsyncStreamCopier2 + * instead. + */ + void init(in nsIInputStream aSource, + in nsIOutputStream aSink, + in nsIEventTarget aTarget, + in boolean aSourceBuffered, + in boolean aSinkBuffered, + in unsigned long aChunkSize, + in boolean aCloseSource, + in boolean aCloseSink); + + /** + * asyncCopy triggers the start of the copy. The observer will be notified + * when the copy completes. + * + * @param aObserver + * receives notifications. + * @param aObserverContext + * passed to observer methods. + */ + void asyncCopy(in nsIRequestObserver aObserver, + in nsISupports aObserverContext); +}; diff --git a/netwerk/base/nsIAsyncStreamCopier2.idl b/netwerk/base/nsIAsyncStreamCopier2.idl new file mode 100644 index 0000000000..7de793f51e --- /dev/null +++ b/netwerk/base/nsIAsyncStreamCopier2.idl @@ -0,0 +1,59 @@ +/* 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 "nsIRequest.idl" + +interface nsIInputStream; +interface nsIOutputStream; +interface nsIRequestObserver; +interface nsIEventTarget; + +[scriptable, uuid(a5b2decf-4ede-4801-8b38-e5fe5db46bf2)] +interface nsIAsyncStreamCopier2 : nsIRequest +{ + /** + * Initialize the stream copier. + * + * If neither the source nor the sink are buffered, buffering will + * be automatically added to the sink. + * + * + * @param aSource + * contains the data to be copied. + * @param aSink + * specifies the destination for the data. + * @param aTarget + * specifies the thread on which the copy will occur. a null value + * is permitted and will cause the copy to occur on an unspecified + * background thread. + * @param aChunkSize + * specifies how many bytes to read/write at a time. this controls + * the granularity of the copying. it should match the segment size + * of the "buffered" streams involved. + * @param aCloseSource + * true if aSource should be closed after copying (this is generally + * the desired behavior). + * @param aCloseSink + * true if aSink should be closed after copying (this is generally + * the desired behavior). + */ + void init(in nsIInputStream aSource, + in nsIOutputStream aSink, + in nsIEventTarget aTarget, + in unsigned long aChunkSize, + in boolean aCloseSource, + in boolean aCloseSink); + + /** + * asyncCopy triggers the start of the copy. The observer will be notified + * when the copy completes. + * + * @param aObserver + * receives notifications. + * @param aObserverContext + * passed to observer methods. + */ + void asyncCopy(in nsIRequestObserver aObserver, + in nsISupports aObserverContext); +}; diff --git a/netwerk/base/nsIAsyncVerifyRedirectCallback.idl b/netwerk/base/nsIAsyncVerifyRedirectCallback.idl new file mode 100644 index 0000000000..8c81a142f8 --- /dev/null +++ b/netwerk/base/nsIAsyncVerifyRedirectCallback.idl @@ -0,0 +1,19 @@ +/* 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 "nsISupports.idl" + +[scriptable, uuid(8d171460-a716-41f1-92be-8c659db39b45)] +interface nsIAsyncVerifyRedirectCallback : nsISupports +{ + /** + * Complement to nsIChannelEventSink asynchronous callback. The result of + * the redirect decision is passed through this callback. + * + * @param result + * Result of the redirect veto decision. If FAILED the redirect has been + * vetoed. If SUCCEEDED the redirect has been allowed by all consumers. + */ + void onRedirectVerifyCallback(in nsresult result); +}; diff --git a/netwerk/base/nsIAuthInformation.idl b/netwerk/base/nsIAuthInformation.idl new file mode 100644 index 0000000000..8fd4a03117 --- /dev/null +++ b/netwerk/base/nsIAuthInformation.idl @@ -0,0 +1,118 @@ +/* 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 "nsISupports.idl" + +/** + * A object that hold authentication information. The caller of + * nsIAuthPrompt2::promptUsernameAndPassword or + * nsIAuthPrompt2::promptPasswordAsync provides an object implementing this + * interface; the prompt implementation can then read the values here to prefill + * the dialog. After the user entered the authentication information, it should + * set the attributes of this object to indicate to the caller what was entered + * by the user. + */ +[scriptable, uuid(0d73639c-2a92-4518-9f92-28f71fea5f20)] +interface nsIAuthInformation : nsISupports +{ + /** @name Flags */ + /* @{ */ + /** + * This dialog belongs to a network host. + */ + const uint32_t AUTH_HOST = 1; + + /** + * This dialog belongs to a proxy. + */ + const uint32_t AUTH_PROXY = 2; + + /** + * This dialog needs domain information. The user interface should show a + * domain field, prefilled with the domain attribute's value. + */ + const uint32_t NEED_DOMAIN = 4; + + /** + * This dialog only asks for password information. Authentication prompts + * SHOULD NOT show a username field. Attempts to change the username field + * will have no effect. nsIAuthPrompt2 implementations should, however, show + * its initial value to the user in some form. For example, a paragraph in + * the dialog might say "Please enter your password for user jsmith at + * server intranet". + * + * This flag is mutually exclusive with #NEED_DOMAIN. + */ + const uint32_t ONLY_PASSWORD = 8; + + /** + * We have already tried to log in for this channel + * (with auth values from a previous promptAuth call), + * but it failed, so we now ask the user to provide a new, correct login. + * + * @see also RFC 2616, Section 10.4.2 + */ + const uint32_t PREVIOUS_FAILED = 16; + + /** + * A cross-origin sub-resource requests an authentication. + * The message presented to users must reflect that. + */ + const uint32_t CROSS_ORIGIN_SUB_RESOURCE = 32; + /* @} */ + + /** + * Flags describing this dialog. A bitwise OR of the flag values + * above. + * + * It is possible that neither #AUTH_HOST nor #AUTH_PROXY are set. + * + * Auth prompts should ignore flags they don't understand; especially, they + * should not throw an exception because of an unsupported flag. + */ + readonly attribute unsigned long flags; + + /** + * The server-supplied realm of the authentication as defined in RFC 2617. + * Can be the empty string if the protocol does not support realms. + * Otherwise, this is a human-readable string like "Secret files". + */ + readonly attribute AString realm; + + /** + * The authentication scheme used for this request, if applicable. If the + * protocol for this authentication does not support schemes, this will be + * the empty string. Otherwise, this will be a string such as "basic" or + * "digest". This string will always be in lowercase. + */ + readonly attribute AUTF8String authenticationScheme; + + /** + * The initial value should be used to prefill the dialog or be shown + * in some other way to the user. + * On return, this parameter should contain the username entered by + * the user. + * This field can only be changed if the #ONLY_PASSWORD flag is not set. + */ + attribute AString username; + + /** + * The initial value should be used to prefill the dialog or be shown + * in some other way to the user. + * The password should not be shown in clear. + * On return, this parameter should contain the password entered by + * the user. + */ + attribute AString password; + + /** + * The initial value should be used to prefill the dialog or be shown + * in some other way to the user. + * On return, this parameter should contain the domain entered by + * the user. + * This attribute is only used if flags include #NEED_DOMAIN. + */ + attribute AString domain; +}; + diff --git a/netwerk/base/nsIAuthModule.idl b/netwerk/base/nsIAuthModule.idl new file mode 100644 index 0000000000..0cbfbb1dab --- /dev/null +++ b/netwerk/base/nsIAuthModule.idl @@ -0,0 +1,146 @@ +/* vim:set ts=4 sw=4 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 "nsISupports.idl" +[uuid(6e35dbc0-49ef-4e2c-b1ea-b72ec64450a2)] +interface nsIAuthModule : nsISupports +{ + /** + * Default behavior. + */ + const unsigned long REQ_DEFAULT = 0; + + /** + * Client and server will be authenticated. + */ + const unsigned long REQ_MUTUAL_AUTH = (1 << 0); + + /** + * The server is allowed to impersonate the client. The REQ_MUTUAL_AUTH + * flag may also need to be specified in order for this flag to take + * effect. + */ + const unsigned long REQ_DELEGATE = (1 << 1); + + /** + * The authentication is required for a proxy connection. + */ + const unsigned long REQ_PROXY_AUTH = (1 << 2); + + /** + * Flags used for telemetry. + */ + const unsigned long NTLM_MODULE_SAMBA_AUTH_PROXY = 0; + const unsigned long NTLM_MODULE_SAMBA_AUTH_DIRECT = 1; + const unsigned long NTLM_MODULE_WIN_API_PROXY = 2; + const unsigned long NTLM_MODULE_WIN_API_DIRECT = 3; + const unsigned long NTLM_MODULE_GENERIC_PROXY = 4; + const unsigned long NTLM_MODULE_GENERIC_DIRECT = 5; + const unsigned long NTLM_MODULE_KERBEROS_PROXY = 6; + const unsigned long NTLM_MODULE_KERBEROS_DIRECT = 7; + + /** Other flags may be defined in the future */ + + /** + * Called to initialize an auth module. The other methods cannot be called + * unless this method succeeds. + * + * @param aServiceName + * the service name, which may be null if not applicable (e.g., for + * NTLM, this parameter should be null). + * @param aServiceFlags + * a bitwise-or of the REQ_ flags defined above (pass REQ_DEFAULT + * for default behavior). + * @param aDomain + * the authentication domain, which may be null if not applicable. + * @param aUsername + * the user's login name + * @param aPassword + * the user's password + */ + void init(in string aServiceName, + in unsigned long aServiceFlags, + in wstring aDomain, + in wstring aUsername, + in wstring aPassword); + + /** + * Called to get the next token in a sequence of authentication steps. + * + * @param aInToken + * A buffer containing the input token (e.g., a challenge from a + * server). This may be null. + * @param aInTokenLength + * The length of the input token. + * @param aOutToken + * If getNextToken succeeds, then aOutToken will point to a buffer + * to be sent in response to the server challenge. The length of + * this buffer is given by aOutTokenLength. The buffer at aOutToken + * must be recycled with a call to free. + * @param aOutTokenLength + * If getNextToken succeeds, then aOutTokenLength contains the + * length of the buffer (number of bytes) pointed to by aOutToken. + */ + void getNextToken([const] in voidPtr aInToken, + in unsigned long aInTokenLength, + out voidPtr aOutToken, + out unsigned long aOutTokenLength); + /** + * Once a security context has been established through calls to GetNextToken() + * it may be used to protect data exchanged between client and server. Calls + * to Wrap() are used to protect items of data to be sent to the server. + * + * @param aInToken + * A buffer containing the data to be sent to the server + * @param aInTokenLength + * The length of the input token + * @param confidential + * If set to true, Wrap() will encrypt the data, otherwise data will + * just be integrity protected (checksummed) + * @param aOutToken + * A buffer containing the resulting data to be sent to the server + * @param aOutTokenLength + * The length of the output token buffer + * + * Wrap() may return NS_ERROR_NOT_IMPLEMENTED, if the underlying authentication + * mechanism does not support security layers. + */ + void wrap([const] in voidPtr aInToken, + in unsigned long aInTokenLength, + in boolean confidential, + out voidPtr aOutToken, + out unsigned long aOutTokenLength); + + /** + * Unwrap() is used to unpack, decrypt, and verify the checksums on data + * returned by a server when security layers are in use. + * + * @param aInToken + * A buffer containing the data received from the server + * @param aInTokenLength + * The length of the input token + * @param aOutToken + * A buffer containing the plaintext data from the server + * @param aOutTokenLength + * The length of the output token buffer + * + * Unwrap() may return NS_ERROR_NOT_IMPLEMENTED, if the underlying + * authentication mechanism does not support security layers. + */ + void unwrap([const] in voidPtr aInToken, + in unsigned long aInTokenLength, + out voidPtr aOutToken, + out unsigned long aOutTokenLength); + +%{C++ + /** + * Create a new instance of an auth module. + * + * @param aType + * The type of the auth module to be constructed. + */ + static already_AddRefed<nsIAuthModule> CreateInstance(const char* aType); +%} +}; diff --git a/netwerk/base/nsIAuthPrompt.idl b/netwerk/base/nsIAuthPrompt.idl new file mode 100644 index 0000000000..08cadf991c --- /dev/null +++ b/netwerk/base/nsIAuthPrompt.idl @@ -0,0 +1,80 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +interface nsIPrompt; + +[scriptable, uuid(358089f9-ee4b-4711-82fd-bcd07fc62061)] +interface nsIAuthPrompt : nsISupports +{ + const uint32_t SAVE_PASSWORD_NEVER = 0; + const uint32_t SAVE_PASSWORD_FOR_SESSION = 1; + const uint32_t SAVE_PASSWORD_PERMANENTLY = 2; + + /** + * Puts up a text input dialog with OK and Cancel buttons. + * Note: prompt uses separate args for the "in" and "out" values of the + * input field, whereas the other functions use a single inout arg. + * @param dialogText The title for the dialog. + * @param text The text to display in the dialog. + * @param passwordRealm The "realm" the password belongs to: e.g. + * ldap://localhost/dc=test + * @param savePassword One of the SAVE_PASSWORD_* options above. + * @param defaultText The default text to display in the text input box. + * @param result The value entered by the user if OK was + * selected. + * @return true for OK, false for Cancel + */ + boolean prompt(in wstring dialogTitle, + in wstring text, + in wstring passwordRealm, + in uint32_t savePassword, + in wstring defaultText, + out wstring result); + + /** + * Puts up a username/password dialog with OK and Cancel buttons. + * Puts up a password dialog with OK and Cancel buttons. + * @param dialogText The title for the dialog. + * @param text The text to display in the dialog. + * @param passwordRealm The "realm" the password belongs to: e.g. + * ldap://localhost/dc=test + * @param savePassword One of the SAVE_PASSWORD_* options above. + * @param user The username entered in the dialog. + * @param pwd The password entered by the user if OK was + * selected. + * @return true for OK, false for Cancel + */ + boolean promptUsernameAndPassword(in wstring dialogTitle, + in wstring text, + in wstring passwordRealm, + in uint32_t savePassword, + inout wstring user, + inout wstring pwd); + + /** + * Puts up a password dialog with OK and Cancel buttons. + * @param dialogText The title for the dialog. + * @param text The text to display in the dialog. + * @param passwordRealm The "realm" the password belongs to: e.g. + * ldap://localhost/dc=test. If a username is + * specified (http://user@site.com) it will be used + * when matching existing logins or saving new ones. + * If no username is specified, only password-only + * logins will be matched or saved. + * Note: if a username is specified, the username + * should be escaped. + * @param savePassword One of the SAVE_PASSWORD_* options above. + * @param pwd The password entered by the user if OK was + * selected. + * @return true for OK, false for Cancel + */ + boolean promptPassword(in wstring dialogTitle, + in wstring text, + in wstring passwordRealm, + in uint32_t savePassword, + inout wstring pwd); +}; diff --git a/netwerk/base/nsIAuthPrompt2.idl b/netwerk/base/nsIAuthPrompt2.idl new file mode 100644 index 0000000000..dda26e9362 --- /dev/null +++ b/netwerk/base/nsIAuthPrompt2.idl @@ -0,0 +1,103 @@ +/* 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 "nsISupports.idl" + +interface nsIAuthPromptCallback; +interface nsIChannel; +interface nsICancelable; +interface nsIAuthInformation; + +/** + * An interface allowing to prompt for a username and password. This interface + * is usually acquired using getInterface on notification callbacks or similar. + * It can be used to prompt users for authentication information, either + * synchronously or asynchronously. + */ +[scriptable, uuid(651395EB-8612-4876-8AC0-A88D4DCE9E1E)] +interface nsIAuthPrompt2 : nsISupports +{ + /** @name Security Levels */ + /* @{ */ + /** + * The password will be sent unencrypted. No security provided. + */ + const uint32_t LEVEL_NONE = 0; + /** + * Password will be sent encrypted, but the connection is otherwise + * insecure. + */ + const uint32_t LEVEL_PW_ENCRYPTED = 1; + /** + * The connection, both for password and data, is secure. + */ + const uint32_t LEVEL_SECURE = 2; + /* @} */ + + /** + * Requests a username and a password. Implementations will commonly show a + * dialog with a username and password field, depending on flags also a + * domain field. + * + * @param aChannel + * The channel that requires authentication. + * @param level + * One of the level constants from above. See there for descriptions + * of the levels. + * @param authInfo + * Authentication information object. The implementation should fill in + * this object with the information entered by the user before + * returning. + * + * @retval true + * Authentication can proceed using the values in the authInfo + * object. + * @retval false + * Authentication should be cancelled, usually because the user did + * not provide username/password. + * + * @note Exceptions thrown from this function will be treated like a + * return value of false. + */ + boolean promptAuth(in nsIChannel aChannel, + in uint32_t level, + in nsIAuthInformation authInfo); + + /** + * Asynchronously prompt the user for a username and password. + * This has largely the same semantics as promptUsernameAndPassword(), + * but must return immediately after calling and return the entered + * data in a callback. + * + * If the user closes the dialog using a cancel button or similar, + * the callback's nsIAuthPromptCallback::onAuthCancelled method must be + * called. + * Calling nsICancelable::cancel on the returned object SHOULD close the + * dialog and MUST call nsIAuthPromptCallback::onAuthCancelled on the provided + * callback. + * + * This implementation may: + * + * 1) Coalesce identical prompts. This means prompts that are guaranteed to + * want the same auth information from the user. A single prompt will be + * shown; then the callbacks for all the coalesced prompts will be notified + * with the resulting auth information. + * 2) Serialize prompts that are all in the same "context" (this might mean + * application-wide, for a given window, or something else depending on + * the user interface) so that the user is not deluged with prompts. + * + * @throw + * This method may throw any exception when the prompt fails to queue e.g + * because of out-of-memory error. It must not throw when the prompt + * could already be potentially shown to the user. In that case information + * about the failure has to come through the callback. This way we + * prevent multiple dialogs shown to the user because consumer may fall + * back to synchronous prompt on synchronous failure of this method. + */ + nsICancelable asyncPromptAuth(in nsIChannel aChannel, + in nsIAuthPromptCallback aCallback, + in nsISupports aContext, + in uint32_t level, + in nsIAuthInformation authInfo); +}; diff --git a/netwerk/base/nsIAuthPromptAdapterFactory.idl b/netwerk/base/nsIAuthPromptAdapterFactory.idl new file mode 100644 index 0000000000..e763d47146 --- /dev/null +++ b/netwerk/base/nsIAuthPromptAdapterFactory.idl @@ -0,0 +1,22 @@ +/* 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 "nsISupports.idl" + +interface nsIAuthPrompt; +interface nsIAuthPrompt2; + +/** + * An interface for wrapping nsIAuthPrompt interfaces to make + * them usable via an nsIAuthPrompt2 interface. + */ +[scriptable, uuid(60e46383-bb9a-4860-8962-80d9c5c05ddc)] +interface nsIAuthPromptAdapterFactory : nsISupports +{ + /** + * Wrap an object implementing nsIAuthPrompt so that it's usable via + * nsIAuthPrompt2. + */ + nsIAuthPrompt2 createAdapter(in nsIAuthPrompt aPrompt); +}; diff --git a/netwerk/base/nsIAuthPromptCallback.idl b/netwerk/base/nsIAuthPromptCallback.idl new file mode 100644 index 0000000000..bf9f2f2ac0 --- /dev/null +++ b/netwerk/base/nsIAuthPromptCallback.idl @@ -0,0 +1,44 @@ +/* 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 "nsISupports.idl" + +interface nsIAuthInformation; + +/** + * Interface for callback methods for the asynchronous nsIAuthPrompt2 method. + * Callers MUST call exactly one method if nsIAuthPrompt2::promptPasswordAsync + * returns successfully. They MUST NOT call any method on this interface before + * promptPasswordAsync returns. + */ +[scriptable, uuid(bdc387d7-2d29-4cac-92f1-dd75d786631d)] +interface nsIAuthPromptCallback : nsISupports +{ + /** + * Authentication information is available. + * + * @param aContext + * The context as passed to promptPasswordAsync + * @param aAuthInfo + * Authentication information. Must be the same object that was passed + * to promptPasswordAsync. + * + * @note Any exceptions thrown from this method should be ignored. + */ + void onAuthAvailable(in nsISupports aContext, + in nsIAuthInformation aAuthInfo); + + /** + * Notification that the prompt was cancelled. + * + * @param aContext + * The context that was passed to promptPasswordAsync. + * @param userCancel + * If false, this prompt was cancelled by calling the + * the cancel method on the nsICancelable; otherwise, + * it was cancelled by the user. + */ + void onAuthCancelled(in nsISupports aContext, in boolean userCancel); +}; + diff --git a/netwerk/base/nsIAuthPromptProvider.idl b/netwerk/base/nsIAuthPromptProvider.idl new file mode 100644 index 0000000000..e8ff122ec2 --- /dev/null +++ b/netwerk/base/nsIAuthPromptProvider.idl @@ -0,0 +1,34 @@ +/* -*- Mode: idl; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +[scriptable, uuid(bd9dc0fa-68ce-47d0-8859-6418c2ae8576)] +interface nsIAuthPromptProvider : nsISupports +{ + /** + * Normal (non-proxy) prompt request. + */ + const uint32_t PROMPT_NORMAL = 0; + + /** + * Proxy auth request. + */ + const uint32_t PROMPT_PROXY = 1; + + /** + * Request a prompt interface for the given prompt reason; + * @throws NS_ERROR_NOT_AVAILABLE if no prompt is allowed or + * available for the given reason. + * + * @param aPromptReason The reason for the auth prompt; + * one of #PROMPT_NORMAL or #PROMPT_PROXY + * @param iid The desired interface, e.g. + * NS_GET_IID(nsIAuthPrompt2). + * @returns an nsIAuthPrompt2 interface, or throws NS_ERROR_NOT_AVAILABLE + */ + void getAuthPrompt(in uint32_t aPromptReason, in nsIIDRef iid, + [iid_is(iid),retval] out nsQIResult result); +}; diff --git a/netwerk/base/nsIBackgroundFileSaver.idl b/netwerk/base/nsIBackgroundFileSaver.idl new file mode 100644 index 0000000000..0b26852c28 --- /dev/null +++ b/netwerk/base/nsIBackgroundFileSaver.idl @@ -0,0 +1,183 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=2 et sw=2 tw=80: */ +/* 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 "nsISupports.idl" + +interface nsIArray; +interface nsIBackgroundFileSaverObserver; +interface nsIFile; + +/** + * Allows saving data to a file, while handling all the input/output on a + * background thread, including the initial file name assignment and any + * subsequent renaming of the target file. + * + * This interface is designed for file downloads. Generally, they start in the + * temporary directory, while the user is selecting the final name. Then, they + * are moved to the chosen target directory with a ".part" extension appended to + * the file name. Finally, they are renamed when the download is completed. + * + * Components implementing both nsIBackgroundFileSaver and nsIStreamListener + * allow data to be fed using an implementation of OnDataAvailable that never + * blocks the calling thread. They suspend the request that drives the stream + * listener in case too much data is being fed, and resume it when the data has + * been written. Calling OnStopRequest does not necessarily close the target + * file, and the Finish method must be called to complete the operation. + * + * Components implementing both nsIBackgroundFileSaver and nsIAsyncOutputStream + * allow data to be fed directly to the non-blocking output stream, that however + * may return NS_BASE_STREAM_WOULD_BLOCK in case too much data is being fed. + * Closing the output stream does not necessarily close the target file, and the + * Finish method must be called to complete the operation. + * + * @remarks Implementations may require the consumer to always call Finish. If + * the object reference is released without calling Finish, a memory + * leak may occur, and the target file might be kept locked. All + * public methods of the interface may only be called from the main + * thread. + */ +[scriptable, uuid(c43544a4-682c-4262-b407-2453d26e660d)] +interface nsIBackgroundFileSaver : nsISupports +{ + /** + * This observer receives notifications when the target file name changes and + * when the operation completes, successfully or not. + * + * @remarks A strong reference to the observer is held. Notification events + * are dispatched to the thread that created the object that + * implements nsIBackgroundFileSaver. + */ + attribute nsIBackgroundFileSaverObserver observer; + + /** + * An Array of Array of Array of bytes, representing a chain of + * X.509 certificates, the last of which signed the downloaded file. + * Each list may belong to a different signer and contain certificates + * all the way up to the root. + * + * @throws NS_ERROR_NOT_AVAILABLE + * In case this is called before the onSaveComplete method has been + * called to notify success, or enableSignatureInfo has not been + * called. + */ + readonly attribute Array<Array<Array<uint8_t> > > signatureInfo; + + /** + * The SHA-256 hash, in raw bytes, associated with the data that was saved. + * + * In case the enableAppend method has been called, the hash computation + * includes the contents of the existing file, if any. + * + * @throws NS_ERROR_NOT_AVAILABLE + * In case the enableSha256 method has not been called, or before the + * onSaveComplete method has been called to notify success. + */ + readonly attribute ACString sha256Hash; + + /** + * Instructs the component to compute the signatureInfo of the target file, + * and make it available in the signatureInfo property. + * + * @remarks This must be set on the main thread before the first call to + * setTarget. + */ + void enableSignatureInfo(); + + /** + * Instructs the component to compute the SHA-256 hash of the target file, and + * make it available in the sha256Hash property. + * + * @remarks This must be set on the main thread before the first call to + * setTarget. + */ + void enableSha256(); + + /** + * Instructs the component to append data to the initial target file, that + * will be specified by the first call to the setTarget method, instead of + * overwriting the file. + * + * If the initial target file does not exist, this method has no effect. + * + * @remarks This must be set on the main thread before the first call to + * setTarget. + */ + void enableAppend(); + + /** + * Sets the name of the output file to be written. The target can be changed + * after data has already been fed, in which case the existing file will be + * moved to the new destination. + * + * In case the specified file already exists, and this method is called for + * the first time, the file may be either overwritten or appended to, based on + * whether the enableAppend method was called. Subsequent calls always + * overwrite the specified target file with the previously saved data. + * + * No file will be written until this function is called at least once. It's + * recommended not to feed any data until the output file is set. + * + * If an input/output error occurs with the specified file, the save operation + * fails. Failure is notified asynchronously through the observer. + * + * @param aTarget + * New output file to be written. + * @param aKeepPartial + * Indicates whether aFile should be kept as partially completed, + * rather than deleted, if the operation fails or is canceled. This is + * generally set for downloads that use temporary ".part" files. + */ + void setTarget(in nsIFile aTarget, in bool aKeepPartial); + + /** + * Terminates access to the output file, then notifies the observer with the + * specified status code. A failure code will force the operation to be + * canceled, in which case the output file will be deleted if requested. + * + * This forces the involved streams to be closed, thus no more data should be + * fed to the component after this method has been called. + * + * This is the last method that should be called on this object, and the + * target file name cannot be changed anymore after this method has been + * called. Conversely, before calling this method, the file can still be + * renamed even if all the data has been fed. + * + * @param aStatus + * Result code that determines whether the operation should succeed or + * be canceled, and is notified to the observer. If the operation + * fails meanwhile for other reasons, or the observer has been already + * notified of completion, this status code is ignored. + */ + void finish(in nsresult aStatus); +}; + +[scriptable, uuid(ee7058c3-6e54-4411-b76b-3ce87b76fcb6)] +interface nsIBackgroundFileSaverObserver : nsISupports +{ + /** + * Called when the name of the output file has been determined. This function + * may be called more than once if the target file is renamed while saving. + * + * @param aSaver + * Reference to the object that raised the notification. + * @param aTarget + * Name of the file that is being written. + */ + void onTargetChange(in nsIBackgroundFileSaver aSaver, in nsIFile aTarget); + + /** + * Called when the operation completed, and the target file has been closed. + * If the operation succeeded, the target file is ready to be used, otherwise + * it might have been already deleted. + * + * @param aSaver + * Reference to the object that raised the notification. + * @param aStatus + * Result code that determines whether the operation succeeded or + * failed, as well as the failure reason. + */ + void onSaveComplete(in nsIBackgroundFileSaver aSaver, in nsresult aStatus); +}; diff --git a/netwerk/base/nsIBufferedStreams.idl b/netwerk/base/nsIBufferedStreams.idl new file mode 100644 index 0000000000..a9876c1d8f --- /dev/null +++ b/netwerk/base/nsIBufferedStreams.idl @@ -0,0 +1,47 @@ +/* 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 "nsIInputStream.idl" +#include "nsIOutputStream.idl" + +/** + * An input stream that reads ahead and keeps a buffer coming from another input + * stream so that fewer accesses to the underlying stream are necessary. + */ +[scriptable, uuid(616f5b48-da09-11d3-8cda-0060b0fc14a3)] +interface nsIBufferedInputStream : nsIInputStream +{ + /** + * @param fillFromStream - add buffering to this stream + * @param bufferSize - specifies the maximum buffer size + */ + void init(in nsIInputStream fillFromStream, + in unsigned long bufferSize); + + /** + * Get the wrapped data stream + */ + readonly attribute nsIInputStream data; +}; + +/** + * An output stream that stores up data to write out to another output stream + * and does the entire write only when the buffer is full, so that fewer writes + * to the underlying output stream are necessary. + */ +[scriptable, uuid(6476378a-da09-11d3-8cda-0060b0fc14a3)] +interface nsIBufferedOutputStream : nsIOutputStream +{ + /** + * @param sinkToStream - add buffering to this stream + * @param bufferSize - specifies the maximum buffer size + */ + void init(in nsIOutputStream sinkToStream, + in unsigned long bufferSize); + + /** + * Get the wrapped data stream + */ + readonly attribute nsIOutputStream data; +}; diff --git a/netwerk/base/nsIByteRangeRequest.idl b/netwerk/base/nsIByteRangeRequest.idl new file mode 100644 index 0000000000..4a10126d69 --- /dev/null +++ b/netwerk/base/nsIByteRangeRequest.idl @@ -0,0 +1,27 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +[scriptable, uuid(C1B1F426-7E83-4759-9F88-0E1B17F49366)] +interface nsIByteRangeRequest : nsISupports +{ + /** + * Returns true IFF this request is a byte range request, otherwise it + * returns false (This is effectively the same as checking to see if + * |startRequest| is zero and |endRange| is the content length.) + */ + readonly attribute boolean isByteRangeRequest; + + /** + * Absolute start position in remote file for this request. + */ + readonly attribute long long startRange; + + /** + * Absolute end postion in remote file for this request + */ + readonly attribute long long endRange; +}; diff --git a/netwerk/base/nsICacheInfoChannel.idl b/netwerk/base/nsICacheInfoChannel.idl new file mode 100644 index 0000000000..7cf70408fd --- /dev/null +++ b/netwerk/base/nsICacheInfoChannel.idl @@ -0,0 +1,176 @@ +/* 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 "nsISupports.idl" + +interface nsIAsyncOutputStream; +interface nsIInputStream; + +%{C++ +#include "nsTArray.h" +namespace mozilla { +namespace net { +class PreferredAlternativeDataTypeParams; +} +} // namespace mozilla +%} + +[ref] native ConstPreferredAlternativeDataTypeArray(const nsTArray<mozilla::net::PreferredAlternativeDataTypeParams>); + +[scriptable, uuid(1fb8ccf2-5fa5-45ec-bc57-8c8022a5d0d3)] +interface nsIInputStreamReceiver : nsISupports +{ + void onInputStreamReady(in nsIInputStream aStream); +}; + +[scriptable, builtinclass, uuid(72c34415-c6eb-48af-851f-772fa9ee5972)] +interface nsICacheInfoChannel : nsISupports +{ + /** + * Get the number of times the cache entry has been opened. This attribute is + * equivalent to nsICachingChannel.cacheToken.fetchCount. + * + * @throws NS_ERROR_NOT_AVAILABLE if the cache entry or the alternate data + * cache entry cannot be read. + */ + readonly attribute int32_t cacheTokenFetchCount; + + /** + * Get expiration time from cache token. This attribute is equivalent to + * nsICachingChannel.cacheToken.expirationTime. + */ + readonly attribute uint32_t cacheTokenExpirationTime; + + /** + * TRUE if this channel's data is being loaded from the cache. This value + * is undefined before the channel fires its OnStartRequest notification + * and after the channel fires its OnStopRequest notification. + */ + boolean isFromCache(); + + /** + * Returns true if the channel raced the cache and network requests. + * In order to determine if the response is coming from the cache or the + * network, the consumer can check isFromCache(). + * The method can only be called after the channel fires its OnStartRequest + * notification. + */ + boolean isRacing(); + + /** + * The unique ID of the corresponding nsICacheEntry from which the response is + * retrieved. By comparing the returned value, we can judge whether the data + * of two distinct nsICacheInfoChannels is from the same nsICacheEntry. This + * scenario could be useful when verifying whether the alternative data from + * one nsICacheInfochannel matches the main data from another one. + * + * Note: NS_ERROR_NOT_AVAILABLE is thrown when a nsICacheInfoChannel has no + * valid corresponding nsICacheEntry. + */ + uint64_t getCacheEntryId(); + + /** + * Set/get the cache key. This integer uniquely identifies the data in + * the cache for this channel. + * + * A cache key retrieved from a particular instance of nsICacheInfoChannel + * could be set on another instance of nsICacheInfoChannel provided the + * underlying implementations are compatible and provided the new + * channel instance was created with the same URI. The implementation of + * nsICacheInfoChannel would be expected to use the cache entry identified + * by the cache token. Depending on the value of nsIRequest::loadFlags, + * the cache entry may be validated, overwritten, or simply read. + * + * The cache key may be 0 indicating that the URI of the channel is + * sufficient to locate the same cache entry. Setting a 0 cache key + * is likewise valid. + */ + attribute unsigned long cacheKey; + + /** + * Tells the channel to behave as if the LOAD_FROM_CACHE flag has been set, + * but without affecting the loads for the entire loadGroup in case of this + * channel being the default load group's channel. + */ + attribute boolean allowStaleCacheContent; + + /** + * Tells the priority for LOAD_CACHE is raised over LOAD_BYPASS_CACHE or + * LOAD_BYPASS_LOCAL_CACHE in case those flags are set at the same time. + */ + attribute boolean preferCacheLoadOverBypass; + + /** + * Calling this method instructs the channel to serve the alternative data + * if that was previously saved in the cache, otherwise it will serve the + * real data. + * @param type + * a string identifying the alt-data format + * @param contentType + * the contentType for which the preference applies. + * an empty contentType means the preference applies for ANY contentType + * @param deliverAltData + * if false, also if alt-data is available, the channel will deliver + * the original data. + * + * The method may be called several times, with different type and contentType. + * + * Must be called before AsyncOpen. + */ + void preferAlternativeDataType(in ACString type, in ACString contentType, + in boolean deliverAltData); + + /** + * Get the preferred alternative data type set by preferAlternativeDataType(). + * The returned types stand for the desired data type instead of the type of the + * information retrieved from the network stack. + */ + [noscript, notxpcom, nostdcall] + ConstPreferredAlternativeDataTypeArray preferredAlternativeDataTypes(); + + /** + * Holds the type of the alternative data representation that the channel + * is returning. + * Is empty string if no alternative data representation was requested, or + * if the requested representation wasn't found in the cache. + * Can only be called during or after OnStartRequest. + */ + readonly attribute ACString alternativeDataType; + + /** + * If preferAlternativeDataType() has been called passing deliverAltData + * equal to false, this method will expose the alt-data inputStream if + * aviable. + */ + void getAltDataInputStream(in ACString type, + in nsIInputStreamReceiver aReceiver); + + /** + * Sometimes when the channel is delivering alt-data, we may want to somehow + * access the original content too. This method asynchronously opens the + * input stream and delivers it to the receiver. + */ + void getOriginalInputStream(in nsIInputStreamReceiver aReceiver); + + /** + * Opens and returns an output stream that a consumer may use to save an + * alternate representation of the data. + * Must be called after the OnStopRequest that delivered the real data. + * The consumer may choose to replace the saved alt representation. + * Opening the output stream will fail if there are any open input streams + * reading the already saved alt representation. After successfully opening + * an output stream, if there is an error before the entire alt data can be + * written successfully, the client must signal failure by passing an error + * code to CloseWithStatus(). + * + * @param type + * type of the alternative data representation + * @param predictedSize + * Predicted size of the data that will be written. It's used to decide + * whether the resulting entry would exceed size limit, in which case + * an error is thrown. If the size isn't known in advance, -1 should be + * passed. + */ + nsIAsyncOutputStream openAlternativeOutputStream(in ACString type, in long long predictedSize); +}; diff --git a/netwerk/base/nsICachingChannel.idl b/netwerk/base/nsICachingChannel.idl new file mode 100644 index 0000000000..1828f15307 --- /dev/null +++ b/netwerk/base/nsICachingChannel.idl @@ -0,0 +1,127 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsICacheInfoChannel.idl" + +interface nsIFile; + +/** + * A channel may optionally implement this interface to allow clients + * to affect its behavior with respect to how it uses the cache service. + * + * This interface provides: + * 1) Support for "stream as file" semantics (for JAR and plugins). + * 2) Support for "pinning" cached data in the cache (for printing and save-as). + * 3) Support for uniquely identifying cached data in cases when the URL + * is insufficient (e.g., HTTP form submission). + */ +[scriptable, builtinclass, uuid(dd1d6122-5ecf-4fe4-8f0f-995e7ab3121a)] +interface nsICachingChannel : nsICacheInfoChannel +{ + /** + * Set/get the cache token... uniquely identifies the data in the cache. + * Holding a reference to this token prevents the cached data from being + * removed. + * + * A cache token retrieved from a particular instance of nsICachingChannel + * could be set on another instance of nsICachingChannel provided the + * underlying implementations are compatible. The implementation of + * nsICachingChannel would be expected to only read from the cache entry + * identified by the cache token and not try to validate it. + * + * The cache token can be QI'd to a nsICacheEntryInfo if more detail + * about the cache entry is needed (e.g., expiration time). + */ + attribute nsISupports cacheToken; + + /** + * The same as above but accessing the offline app cache token if there + * is any. + * + * @throws + * NS_ERROR_NOT_AVAILABLE when there is not offline cache token + */ + attribute nsISupports offlineCacheToken; + + /** + * Instructs the channel to only store the metadata of the entry, and not + * the content. When reading an existing entry, this automatically sets + * LOAD_ONLY_IF_MODIFIED flag. + * Must be called before asyncOpen(). + */ + attribute boolean cacheOnlyMetadata; + + /** + * Tells the channel to use the pinning storage. + */ + attribute boolean pin; + + /** + * Overrides cache validation for a time specified in seconds. + * + * @param aSecondsToTheFuture + * + */ + void forceCacheEntryValidFor(in unsigned long aSecondsToTheFuture); + + /************************************************************************** + * Caching channel specific load flags: + */ + + /** + * This load flag inhibits fetching from the net. An error of + * NS_ERROR_DOCUMENT_NOT_CACHED will be sent to the listener's + * onStopRequest if network IO is necessary to complete the request. + * + * This flag can be used to find out whether fetching this URL would + * cause validation of the cache entry via the network. + * + * Combining this flag with LOAD_BYPASS_LOCAL_CACHE will cause all + * loads to fail. + */ + const unsigned long LOAD_NO_NETWORK_IO = 1 << 26; + + /** + * This load flag causes the offline cache to be checked when fetching + * a request. It will be set automatically if the browser is offline. + * + * This flag will not be transferred through a redirect. + */ + const unsigned long LOAD_CHECK_OFFLINE_CACHE = 1 << 27; + + /** + * This load flag causes the local cache to be skipped when fetching a + * request. Unlike LOAD_BYPASS_CACHE, it does not force an end-to-end load + * (i.e., it does not affect proxy caches). + */ + const unsigned long LOAD_BYPASS_LOCAL_CACHE = 1 << 28; + + /** + * This load flag causes the local cache to be skipped if the request + * would otherwise block waiting to access the cache. + */ + const unsigned long LOAD_BYPASS_LOCAL_CACHE_IF_BUSY = 1 << 29; + + /** + * This load flag inhibits fetching from the net if the data in the cache + * has been evicted. An error of NS_ERROR_DOCUMENT_NOT_CACHED will be sent + * to the listener's onStopRequest in this case. This flag is set + * automatically when the application is offline. + */ + const unsigned long LOAD_ONLY_FROM_CACHE = 1 << 30; + + /** + * This load flag controls what happens when a document would be loaded + * from the cache to satisfy a call to AsyncOpen. If this attribute is + * set to TRUE, then the document will not be loaded from the cache. A + * stream listener can check nsICachingChannel::isFromCache to determine + * if the AsyncOpen will actually result in data being streamed. + * + * If this flag has been set, and the request can be satisfied via the + * cache, then the OnDataAvailable events will be skipped. The listener + * will only see OnStartRequest followed by OnStopRequest. + */ + const unsigned long LOAD_ONLY_IF_MODIFIED = 1 << 31; +}; diff --git a/netwerk/base/nsICancelable.idl b/netwerk/base/nsICancelable.idl new file mode 100644 index 0000000000..c558dc6e27 --- /dev/null +++ b/netwerk/base/nsICancelable.idl @@ -0,0 +1,24 @@ +/* -*- 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 "nsISupports.idl" + +/** + * This interface provides a means to cancel an operation that is in progress. + */ +[scriptable, uuid(d94ac0a0-bb18-46b8-844e-84159064b0bd)] +interface nsICancelable : nsISupports +{ + /** + * Call this method to request that this object abort whatever operation it + * may be performing. + * + * @param aReason + * Pass a failure code to indicate the reason why this operation is + * being canceled. It is an error to pass a success code. + */ + void cancel(in nsresult aReason); +}; diff --git a/netwerk/base/nsICaptivePortalService.idl b/netwerk/base/nsICaptivePortalService.idl new file mode 100644 index 0000000000..9b6d104fa6 --- /dev/null +++ b/netwerk/base/nsICaptivePortalService.idl @@ -0,0 +1,68 @@ +/* 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 "nsISupports.idl" + +[scriptable, uuid(b5fd5629-d04c-4138-9529-9311f291ecd4)] +interface nsICaptivePortalServiceCallback : nsISupports +{ + /** + * Invoke callbacks after captive portal detection finished. + */ + void complete(in bool success, in nsresult error); +}; + +/** + * Service used for captive portal detection. + * The service is only active in the main process. It is also available in the + * content process, but only to mirror the captive portal state from the main + * process. + */ +[scriptable, uuid(bdbe0555-fc3d-4f7b-9205-c309ceb2d641)] +interface nsICaptivePortalService : nsISupports +{ + const long UNKNOWN = 0; + const long NOT_CAPTIVE = 1; + const long UNLOCKED_PORTAL = 2; + const long LOCKED_PORTAL = 3; + + /** + * Called from XPCOM to trigger a captive portal recheck. + * A network request will only be performed if no other checks are currently + * ongoing. + * Will not do anything if called in the content process. + */ + void recheckCaptivePortal(); + + /** + * Returns the state of the captive portal. + */ + readonly attribute long state; + + /** + * Returns the time difference between NOW and the last time a request was + * completed in milliseconds. + */ + readonly attribute unsigned long long lastChecked; +}; + +%{C++ +/** + * This observer notification will be emitted when the captive portal state + * changes. After receiving it, the ContentParent will send an IPC message + * to the ContentChild, which will set the state in the captive portal service + * in the child. + */ +#define NS_IPC_CAPTIVE_PORTAL_SET_STATE "ipc:network:captive-portal-set-state" + +/** + * This notification will be emitted when the captive portal service has + * determined that we can connect to the internet. + * The service will pass either "captive" if there is an unlocked captive portal + * present, or "clear" if no captive portal was detected. + * Note: this notification only gets sent in the parent process. + */ +#define NS_CAPTIVE_PORTAL_CONNECTIVITY "network:captive-portal-connectivity" + +%} diff --git a/netwerk/base/nsIChannel.idl b/netwerk/base/nsIChannel.idl new file mode 100644 index 0000000000..f089c5aecc --- /dev/null +++ b/netwerk/base/nsIChannel.idl @@ -0,0 +1,398 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsIRequest.idl" +#include "nsILoadInfo.idl" + +interface nsIURI; +interface nsIInterfaceRequestor; +interface nsIInputStream; +interface nsIStreamListener; + +%{C++ +#include "nsCOMPtr.h" +%} + +/** + * The nsIChannel interface allows clients to construct "GET" requests for + * specific protocols, and manage them in a uniform way. Once a channel is + * created (via nsIIOService::newChannel), parameters for that request may + * be set by using the channel attributes, or by QI'ing to a subclass of + * nsIChannel for protocol-specific parameters. Then, the URI can be fetched + * by calling nsIChannel::open or nsIChannel::asyncOpen. + * + * After a request has been completed, the channel is still valid for accessing + * protocol-specific results. For example, QI'ing to nsIHttpChannel allows + * response headers to be retrieved for the corresponding http transaction. + * + * This interface must be used only from the XPCOM main thread. + */ +[scriptable, uuid(2c389865-23db-4aa7-9fe5-60cc7b00697e)] +interface nsIChannel : nsIRequest +{ + /** + * The original URI used to construct the channel. This is used in + * the case of a redirect or URI "resolution" (e.g. resolving a + * resource: URI to a file: URI) so that the original pre-redirect + * URI can still be obtained. This is never null. Attempts to + * set it to null must throw. + * + * NOTE: this is distinctly different from the http Referer (referring URI), + * which is typically the page that contained the original URI (accessible + * from nsIHttpChannel). + */ + attribute nsIURI originalURI; + + /** + * The URI corresponding to the channel. Its value is immutable. + */ + readonly attribute nsIURI URI; + + /** + * The owner, corresponding to the entity that is responsible for this + * channel. Used by the security manager to grant or deny privileges to + * mobile code loaded from this channel. + * + * NOTE: this is a strong reference to the owner, so if the owner is also + * holding a strong reference to the channel, care must be taken to + * explicitly drop its reference to the channel. + */ + attribute nsISupports owner; + + /** + * The notification callbacks for the channel. This is set by clients, who + * wish to provide a means to receive progress, status and protocol-specific + * notifications. If this value is NULL, the channel implementation may use + * the notification callbacks from its load group. The channel may also + * query the notification callbacks from its load group if its notification + * callbacks do not supply the requested interface. + * + * Interfaces commonly requested include: nsIProgressEventSink, nsIPrompt, + * and nsIAuthPrompt/nsIAuthPrompt2. + * + * When the channel is done, it must not continue holding references to + * this object. + * + * NOTE: A channel implementation should take care when "caching" an + * interface pointer queried from its notification callbacks. If the + * notification callbacks are changed, then a cached interface pointer may + * become invalid and may therefore need to be re-queried. + */ + attribute nsIInterfaceRequestor notificationCallbacks; + + /** + * Transport-level security information (if any) corresponding to the + * channel. + * + * NOTE: In some circumstances TLS information is propagated onto + * non-nsIHttpChannel objects to indicate that their contents were likely + * delivered over TLS all the same. + * + * FIXME(bz, bug 1528449) is that still true now that + * document.open() doesn't do this? + */ + readonly attribute nsISupports securityInfo; + + /** + * The MIME type of the channel's content if available. + * + * NOTE: the content type can often be wrongly specified (e.g., wrong file + * extension, wrong MIME type, wrong document type stored on a server, etc.), + * and the caller most likely wants to verify with the actual data. + * + * Setting contentType before the channel has been opened provides a hint + * to the channel as to what the MIME type is. The channel may ignore this + * hint in deciding on the actual MIME type that it will report. + * + * Setting contentType after onStartRequest has been fired or after open() + * is called will override the type determined by the channel. + * + * Setting contentType between the time that asyncOpen() is called and the + * time when onStartRequest is fired has undefined behavior at this time. + * + * The value of the contentType attribute is a lowercase string. A value + * assigned to this attribute will be parsed and normalized as follows: + * 1- any parameters (delimited with a ';') will be stripped. + * 2- if a charset parameter is given, then its value will replace the + * the contentCharset attribute of the channel. + * 3- the stripped contentType will be lowercased. + * Any implementation of nsIChannel must follow these rules. + */ + attribute ACString contentType; + + /** + * The character set of the channel's content if available and if applicable. + * This attribute only applies to textual data. + * + * The value of the contentCharset attribute is a mixedcase string. + */ + attribute ACString contentCharset; + + /** + * The length of the data associated with the channel if available. A value + * of -1 indicates that the content length is unknown. Note that this is a + * 64-bit value and obsoletes the "content-length" property used on some + * channels. + */ + attribute int64_t contentLength; + + /** + * Synchronously open the channel. + * + * @return blocking input stream to the channel's data. + * + * NOTE: nsIChannel implementations are not required to implement this + * method. Moreover, since this method may block the calling thread, it + * should not be called on a thread that processes UI events. Like any + * other nsIChannel method it must not be called on any thread other + * than the XPCOM main thread. + * + * NOTE: Implementations should throw NS_ERROR_IN_PROGRESS if the channel + * is reopened. + */ + nsIInputStream open(); + + /** + * Asynchronously open this channel. Data is fed to the specified stream + * listener as it becomes available. The stream listener's methods are + * called on the thread that calls asyncOpen and are not called until + * after asyncOpen returns. If asyncOpen returns successfully, the + * channel promises to call at least onStartRequest and onStopRequest. + * + * If the nsIRequest object passed to the stream listener's methods is not + * this channel, an appropriate onChannelRedirect notification needs to be + * sent to the notification callbacks before onStartRequest is called. + * Once onStartRequest is called, all following method calls on aListener + * will get the request that was passed to onStartRequest. + * + * If the channel's and loadgroup's notification callbacks do not provide + * an nsIChannelEventSink when onChannelRedirect would be called, that's + * equivalent to having called onChannelRedirect. + * + * If asyncOpen returns successfully, the channel is responsible for + * keeping itself alive until it has called onStopRequest on aListener or + * called onChannelRedirect. + * + * Implementations are allowed to synchronously add themselves to the + * associated load group (if any). + * + * NOTE: Implementations should throw NS_ERROR_ALREADY_OPENED if the + * channel is reopened. + * NOTE: Implementations should throw an error if the channel has been + * cancelled prior asyncOpen being called. + * + * @param aListener the nsIStreamListener implementation + * @see nsIChannelEventSink for onChannelRedirect + */ + void asyncOpen(in nsIStreamListener aListener); + + /** + * True if the channel has been canceled. + */ + [must_use] readonly attribute boolean canceled; + + /************************************************************************** + * Channel specific load flags: + * + * Bits 16-31 are reserved for future use by this interface or one of its + * derivatives (e.g., see nsICachingChannel). + */ + + /** + * Set (e.g., by the docshell) to indicate whether or not the channel + * corresponds to a document URI. + * While setting this flag is sufficient to mark a channel as a document + * load, _checking_ whether the channel is a document load requires the use + * of the new channel.isDocument + */ + const unsigned long LOAD_DOCUMENT_URI = 1 << 16; + + /** + * If the end consumer for this load has been retargeted after discovering + * its content, this flag will be set: + */ + const unsigned long LOAD_RETARGETED_DOCUMENT_URI = 1 << 17; + + /** + * This flag is set to indicate that this channel is replacing another + * channel. This means that: + * + * 1) the stream listener this channel will be notifying was initially + * passed to the asyncOpen method of some other channel + * + * and + * + * 2) this channel's URI is a better identifier of the resource being + * accessed than this channel's originalURI. + * + * This flag can be set, for example, for redirects or for cases when a + * single channel has multiple parts to it (and thus can follow + * onStopRequest with another onStartRequest/onStopRequest pair, each pair + * for a different request). + */ + const unsigned long LOAD_REPLACE = 1 << 18; + + /** + * Set (e.g., by the docshell) to indicate whether or not the channel + * corresponds to an initial document URI load (e.g., link click). + */ + const unsigned long LOAD_INITIAL_DOCUMENT_URI = 1 << 19; + + /** + * Set (e.g., by the URILoader) to indicate whether or not the end consumer + * for this load has been determined. + */ + const unsigned long LOAD_TARGETED = 1 << 20; + + /** + * If this flag is set, the channel should call the content sniffers as + * described in nsNetCID.h about NS_CONTENT_SNIFFER_CATEGORY. + * + * Note: Channels may ignore this flag; however, new channel implementations + * should only do so with good reason. + */ + const unsigned long LOAD_CALL_CONTENT_SNIFFERS = 1 << 21; + + /** + * This flag tells the channel to bypass URL classifier service check + * when opening the channel. + */ + const unsigned long LOAD_BYPASS_URL_CLASSIFIER = 1 << 22; + + /** + * If this flag is set, the media-type content sniffer will be allowed + * to override any server-set content-type. Otherwise it will only + * be allowed to override "no content type" and application/octet-stream. + */ + const unsigned long LOAD_MEDIA_SNIFFER_OVERRIDES_CONTENT_TYPE = 1 << 23; + + /** + * Set to let explicitely provided credentials be used over credentials + * we have cached previously. In some situations like form login using HTTP + * auth via XMLHttpRequest we need to let consumers override the cached + * credentials explicitely. For form login 403 response instead of 401 is + * usually used to prevent an auth dialog. But any code other then 401/7 + * will leave original credentials in the cache and there is then no way + * to override them for the same user name. + */ + const unsigned long LOAD_EXPLICIT_CREDENTIALS = 1 << 24; + + /** + * Set to force bypass of any service worker interception of the channel. + */ + const unsigned long LOAD_BYPASS_SERVICE_WORKER = 1 << 25; + + // nsICachingChannel load flags begin at bit 26. + + /** + * Access to the type implied or stated by the Content-Disposition header + * if available and if applicable. This allows determining inline versus + * attachment. + * + * Setting contentDisposition provides a hint to the channel about the + * disposition. If the hint is DISPOSITION_ATTACHMENT and a normal + * Content-Disposition header is present, the hinted value will always be + * used. The value from Content-Disposition header is only used when + * the hinted value is not DISPOSITION_ATTACHMENT. + * If the header is missing the hinted value will be used if set. + * + * Implementations should throw NS_ERROR_NOT_AVAILABLE if the header either + * doesn't exist for this type of channel or is empty, and return + * DISPOSITION_ATTACHMENT if an invalid/noncompliant value is present. + */ + attribute unsigned long contentDisposition; + const unsigned long DISPOSITION_INLINE = 0; + const unsigned long DISPOSITION_ATTACHMENT = 1; + + /** + * Access to the filename portion of the Content-Disposition header if + * available and if applicable. This allows getting the preferred filename + * without having to parse it out yourself. + * + * Setting contentDispositionFilename provides a hint to the channel about + * the disposition. If a normal Content-Disposition header is present its + * value will always be used. If it is missing the hinted value will be + * used if set. + * + * Implementations should throw NS_ERROR_NOT_AVAILABLE if the header doesn't + * exist for this type of channel, if the header is empty, if the header + * doesn't contain a filename portion, or the value of the filename + * attribute is empty/missing. + */ + attribute AString contentDispositionFilename; + + /** + * Access to the raw Content-Disposition header if available and applicable. + * + * Implementations should throw NS_ERROR_NOT_AVAILABLE if the header either + * doesn't exist for this type of channel or is empty. + * + * @deprecated Use contentDisposition/contentDispositionFilename instead. + */ + readonly attribute ACString contentDispositionHeader; + + /** + * The LoadInfo object contains information about a network load, why it + * was started, and how we plan on using the resulting response. + * If a network request is redirected, the new channel will receive a new + * LoadInfo object. The new object will contain mostly the same + * information as the pre-redirect one, but updated as appropriate. + * For detailed information about what parts of LoadInfo are updated on + * redirect, see documentation on individual properties. + */ + attribute nsILoadInfo loadInfo; + + /** + * Returns true if the channel is used to create a document. + * It returns true if the loadFlags have LOAD_DOCUMENT_URI set, or if + * LOAD_HTML_OBJECT_DATA is set and the channel has the appropriate + * MIME type. + * Note: May have the wrong value if called before OnStartRequest as we + * don't know the MIME type yet. + */ + readonly attribute bool isDocument; + +%{ C++ + inline bool IsDocument() + { + bool isDocument = false; + if (NS_SUCCEEDED(GetIsDocument(&isDocument)) && isDocument) { + return true; + } + return false; + } + + inline already_AddRefed<nsILoadInfo> LoadInfo() + { + nsCOMPtr<nsILoadInfo> result; + mozilla::DebugOnly<nsresult> rv = GetLoadInfo(getter_AddRefs(result)); + MOZ_ASSERT(NS_SUCCEEDED(rv) && result); + return result.forget(); + } +%} + +}; + +[builtinclass, scriptable, uuid(1ebbff64-d742-4f4a-aad5-4df2d1eb937a)] +interface nsIIdentChannel : nsIChannel +{ + /** + * Unique ID of the channel, shared between parent and child. Needed if + * the channel activity needs to be monitored across process boundaries, + * like in devtools net monitor. See bug 1274556. + */ + [must_use] attribute uint64_t channelId; + +%{ C++ + inline uint64_t ChannelId() + { + uint64_t value = 0; + if (NS_SUCCEEDED(GetChannelId(&value))) { + return value; + } + return 0; + } +%} +}; diff --git a/netwerk/base/nsIChannelEventSink.idl b/netwerk/base/nsIChannelEventSink.idl new file mode 100644 index 0000000000..76a1e290c0 --- /dev/null +++ b/netwerk/base/nsIChannelEventSink.idl @@ -0,0 +1,101 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* vim:set 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/. */ + +#include "nsISupports.idl" + +interface nsIChannel; +interface nsIAsyncVerifyRedirectCallback; + +/** + * Implement this interface to receive control over various channel events. + * Channels will try to get this interface from a channel's + * notificationCallbacks or, if not available there, from the loadGroup's + * notificationCallbacks. + * + * These methods are called before onStartRequest. + */ +[scriptable, uuid(0197720d-37ed-4e75-8956-d0d296e4d8a6)] +interface nsIChannelEventSink : nsISupports +{ + /** + * This is a temporary redirect. New requests for this resource should + * continue to use the URI of the old channel. + * + * The new URI may be identical to the old one. + */ + const unsigned long REDIRECT_TEMPORARY = 1 << 0; + + /** + * This is a permanent redirect. New requests for this resource should use + * the URI of the new channel (This might be an HTTP 301 reponse). + * If this flag is not set, this is a temporary redirect. + * + * The new URI may be identical to the old one. + */ + const unsigned long REDIRECT_PERMANENT = 1 << 1; + + /** + * This is an internal redirect, i.e. it was not initiated by the remote + * server, but is specific to the channel implementation. + * + * The new URI may be identical to the old one. + */ + const unsigned long REDIRECT_INTERNAL = 1 << 2; + + /** + * This is a special-cased redirect coming from hitting HSTS upgrade + * redirect from http to https only. In some cases this type of redirect + * may be considered as safe despite not being the-same-origin redirect. + */ + const unsigned long REDIRECT_STS_UPGRADE = 1 << 3; + + /** + * Called when a redirect occurs. This may happen due to an HTTP 3xx status + * code. The purpose of this method is to notify the sink that a redirect + * is about to happen, but also to give the sink the right to veto the + * redirect by throwing or passing a failure-code in the callback. + * + * Note that vetoing the redirect simply means that |newChannel| will not + * be opened. It is important to understand that |oldChannel| will continue + * loading as if it received a HTTP 200, which includes notifying observers + * and possibly display or process content attached to the HTTP response. + * If the sink wants to prevent this loading it must explicitly deal with + * it, e.g. by calling |oldChannel->Cancel()| + * + * There is a certain freedom in implementing this method: + * + * If the return-value indicates success, a callback on |callback| is + * required. This callback can be done from within asyncOnChannelRedirect + * (effectively making the call synchronous) or at some point later + * (making the call asynchronous). Repeat: A callback must be done + * if this method returns successfully. + * + * If the return value indicates error (method throws an exception) + * the redirect is vetoed and no callback must be done. Repeat: No + * callback must be done if this method throws! + * + * @see nsIAsyncVerifyRedirectCallback::onRedirectVerifyCallback() + * + * @param oldChannel + * The channel that's being redirected. + * @param newChannel + * The new channel. This channel is not opened yet. + * @param flags + * Flags indicating the type of redirect. A bitmask consisting + * of flags from above. + * One of REDIRECT_TEMPORARY and REDIRECT_PERMANENT will always be + * set. + * @param callback + * Object to inform about the async result of this method + * + * @throw <any> Throwing an exception will cause the redirect to be + * cancelled + */ + void asyncOnChannelRedirect(in nsIChannel oldChannel, + in nsIChannel newChannel, + in unsigned long flags, + in nsIAsyncVerifyRedirectCallback callback); +}; diff --git a/netwerk/base/nsIChildChannel.idl b/netwerk/base/nsIChildChannel.idl new file mode 100644 index 0000000000..3b57013536 --- /dev/null +++ b/netwerk/base/nsIChildChannel.idl @@ -0,0 +1,34 @@ +/* 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 "nsISupports.idl" + +interface nsIStreamListener; + +/** + * Implemented by content side of IPC protocols. + */ + +[scriptable, uuid(c45b92ae-4f07-41dd-b0ef-aa044eeabb1e)] +interface nsIChildChannel : nsISupports +{ + /** + * Create the chrome side of the IPC protocol and join an existing 'real' + * channel on the parent process. The id is provided by + * nsIRedirectChannelRegistrar on the chrome process and pushed to the child + * protocol as an argument to event starting a redirect. + * + * Primarilly used in HttpChannelChild::Redirect1Begin on a newly created + * child channel, where the new channel is intended to be created on the + * child process. + */ + void connectParent(in uint32_t registrarId); + + /** + * As AsyncOpen is called on the chrome process for redirect target channels, + * we have to inform the child side of the protocol of that fact by a special + * method. + */ + void completeRedirectSetup(in nsIStreamListener aListener); +}; diff --git a/netwerk/base/nsIClassOfService.idl b/netwerk/base/nsIClassOfService.idl new file mode 100644 index 0000000000..e17edaa8dc --- /dev/null +++ b/netwerk/base/nsIClassOfService.idl @@ -0,0 +1,93 @@ +/* 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 "nsISupports.idl" + +/** + * nsIClassOfService.idl + * + * Used to express class dependencies and characteristics - complimentary to + * nsISupportsPriority which is used to express weight + * + * Channels that implement this interface may make use of this + * information in different ways. + */ + +[scriptable, uuid(1ccb58ec-5e07-4cf9-a30d-ac5490d23b41)] +interface nsIClassOfService : nsISupports +{ + attribute unsigned long classFlags; + + void clearClassFlags(in unsigned long flags); + void addClassFlags(in unsigned long flags); + + // All these flags have a (de)prioritization effect. + + // In the HTTP/1 world the priority is considered for all requests inside a so + // called 'Request Context' which is a context common to all sub-resources + // belonging to a single top level window (RequestContextService). Requests + // marked with the Leader flag are blocking (preventing from being sent to the + // server) all other resource loads except those marked with the Unblocked + // flag. Other classes run in parallel - neither being blocked nor blocking. + // The Leader flag is used only for <head> blocking resources (sync and + // defer javascript resources and stylesheets.) Purpose is to deliver these + // first-paint and domcontentloaded blocking resources as soon as possbile. + + // In the HTTP/2 world it's different. Priorities are done only per HTTP/2 + // session, normally we have one session per one origin (including origin + // attributes!) Requests are dispatched (sent) immediately on an HTTP/2 + // session. Each session has artificial streams (groups) relating to the class + // of service flags (Leader, Other, Background, Speculative, Follower, + // UrgentStart), each such a stream is given a different weight (only way to + // give a stream a priority in HTTP/2) reflecting the desired request group + // priority. Actual request streams are then dependent on these artificial + // streams (groups). nsISupportsPriority of each request is passed as a weight + // on the HTTP/2 stream to prioritize streams in the same group. A stream can + // also be dependent on other stream. We have dependency of Followers on + // Leaders, hence everything set the Follower flag should be processed by the + // server after Leaders. Same for Speculative being dependent on Background. The + // tree is created and used here: + // https://searchfox.org/mozilla-central/rev/cc280c4be94ff8cf64a27cc9b3d6831ffa49fa45/netwerk/protocol/http/Http2Session.cpp#1053-1070 + // https://searchfox.org/mozilla-central/rev/cc280c4be94ff8cf64a27cc9b3d6831ffa49fa45/netwerk/protocol/http/Http2Stream.cpp#1338 + // For detailed description of how HTTP/2 server should handle the priorities + // and dependencies see: + // https://developers.google.com/web/fundamentals/performance/http2/#stream_prioritization + // Please note that the dependecies and weights we are sending to the server + // are only suggestions, the server may completely ignore it. + + // Leaders (should) block all other resources except Unblocked. This flag + // also priortizes HTTP cache reading queue by blocking all other cache + // requests. + const unsigned long Leader = 1 << 0; + // The Follower flag is currently unused! + const unsigned long Follower = 1 << 1; + // The Speculative flag is currently unused! + const unsigned long Speculative = 1 << 2; + // The Background flag is currently only used for Beacon. + const unsigned long Background = 1 << 3; + // Requests marked with this flag are not blocked by Leaders. This is mainly + // used for probing-like XMLHttpRequests that may block delivery of head + // blocking resources, e.g. CSS files tailored for the UA. + const unsigned long Unblocked = 1 << 4; + // Throttleable flag allows response throttling of the resource load. Note + // that this functionality is currently disabled. + const unsigned long Throttleable = 1 << 5; + // UrgentStart makes the request temporarily extend HTTP/1 connection + // parallelism limits. Used mainly for navigational requests (top level html) + // and any request considered coming from a user interaction to make reaction + // of the browser as fast as possible and not blocked. + const unsigned long UrgentStart = 1 << 6; + // Specifically disables throttling under any circumstances, used for media + // responses mainly. + const unsigned long DontThrottle = 1 << 7; + // Enforce tailing on this load; any of Leader, Unblocked, UrgentStart, + // TailForbidden overrule this flag (disable tailing.) + const unsigned long Tail = 1 << 8; + // Tailing may be engaged regardless if the load is marked Unblocked when some + // other conditions are met later, like when the load is found to be a + // tracker. + const unsigned long TailAllowed = 1 << 9; + // Tailing not allowed under any circumstances or combination of flags. + const unsigned long TailForbidden = 1 << 10; +}; diff --git a/netwerk/base/nsIClassifiedChannel.idl b/netwerk/base/nsIClassifiedChannel.idl new file mode 100644 index 0000000000..7108e0be6b --- /dev/null +++ b/netwerk/base/nsIClassifiedChannel.idl @@ -0,0 +1,195 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "nsISupports.idl" + +/** + * nsIClassifiedChannel + * + * A channel may optionally implement this interface if it carries classified + * result information of channel classifier. The information contains, for + * example, the name of matched table and the name of matched provider. + */ +[builtinclass, scriptable, uuid(70cf6091-a1de-4aa8-8224-058f8964be31)] +interface nsIClassifiedChannel : nsISupports +{ + /** + * Sets matched info of the classified channel. + * + * @param aList + * Name of the Safe Browsing list that matched (e.g. goog-phish-shavar). + * @param aProvider + * Name of the Safe Browsing provider that matched (e.g. google) + * @param aFullHash + * Full hash of URL that matched Safe Browsing list. + */ + void setMatchedInfo(in ACString aList, + in ACString aProvider, + in ACString aFullHash); + + /** + * Name of the list that matched + */ + readonly attribute ACString matchedList; + + /** + * Name of provider that matched + */ + readonly attribute ACString matchedProvider; + + /** + * Full hash of URL that matched + */ + readonly attribute ACString matchedFullHash; + + /** + * Sets matched tracking info of the classified channel. + * + * @param aLists + * Name of the Tracking Protection list that matched (e.g. content-track-digest256). + * @param aFullHash + * Full hash of URLs that matched Tracking Protection list. + */ + void setMatchedTrackingInfo(in Array<ACString> aLists, + in Array<ACString> aFullHashes); + + /** + * Name of the lists that matched + */ + readonly attribute Array<ACString> matchedTrackingLists; + + /** + * Full hash of URLs that matched + */ + readonly attribute Array<ACString> matchedTrackingFullHashes; + + /** + * Returns the classification flags if the channel has been processed by + * URL-Classifier features and is considered first-party. + */ + [infallible] readonly attribute unsigned long firstPartyClassificationFlags; + + /** + * Returns the classification flags if the channel has been processed by + * URL-Classifier features and is considered third-party with the top + * window URI. + */ + [infallible] readonly attribute unsigned long thirdPartyClassificationFlags; + + /* + * Returns the classification flags if the channel has been processed by + * URL-Classifier features. This value is equal to + * "firstPartyClassificationFlags || thirdPartyClassificationFlags". + * + * Note that top-level channels could be classified as well. + * In order to identify third-party resources specifically, use + * classificationThirdPartyFlags; + */ + [infallible] readonly attribute unsigned long classificationFlags; + + cenum ClassificationFlags : 32 { + /** + * The resource is on the fingerprinting list. + */ + CLASSIFIED_FINGERPRINTING = 0x0001, + CLASSIFIED_FINGERPRINTING_CONTENT = 0x0080, + + /** + * The resource is on the cryptomining list. + */ + CLASSIFIED_CRYPTOMINING = 0x0002, + CLASSIFIED_CRYPTOMINING_CONTENT = 0x0100, + + /** + * The following are about tracking annotation and are available only + * if the privacy.trackingprotection.annotate_channels pref. + * CLASSIFIED_TRACKING is set if we are not able to identify the + * type of classification. + */ + CLASSIFIED_TRACKING = 0x0004, + CLASSIFIED_TRACKING_AD = 0x0008, + CLASSIFIED_TRACKING_ANALYTICS = 0x0010, + CLASSIFIED_TRACKING_SOCIAL = 0x0020, + CLASSIFIED_TRACKING_CONTENT = 0x0040, + + /** + * The following are about social tracking. + */ + CLASSIFIED_SOCIALTRACKING = 0x0200, + CLASSIFIED_SOCIALTRACKING_FACEBOOK = 0x0400, + CLASSIFIED_SOCIALTRACKING_LINKEDIN = 0x0800, + CLASSIFIED_SOCIALTRACKING_TWITTER = 0x1000, + + /** + * This is exposed to help to identify tracking classification using the + * basic lists. + */ + CLASSIFIED_ANY_BASIC_TRACKING = CLASSIFIED_TRACKING | + CLASSIFIED_TRACKING_AD | CLASSIFIED_TRACKING_ANALYTICS | + CLASSIFIED_TRACKING_SOCIAL | CLASSIFIED_FINGERPRINTING, + + /** + * This is exposed to help to identify tracking classification using the + * strict lists. + */ + CLASSIFIED_ANY_STRICT_TRACKING = CLASSIFIED_ANY_BASIC_TRACKING | + CLASSIFIED_TRACKING_CONTENT | CLASSIFIED_FINGERPRINTING_CONTENT, + + /** + * This is exposed to help to identify social tracking classification + * flags. + */ + CLASSIFIED_ANY_SOCIAL_TRACKING = CLASSIFIED_SOCIALTRACKING | + CLASSIFIED_SOCIALTRACKING_FACEBOOK | + CLASSIFIED_SOCIALTRACKING_LINKEDIN | CLASSIFIED_SOCIALTRACKING_TWITTER, + }; + + /** + * Returns true if the channel has been processed by URL-Classifier features + * and is considered third-party with the top window URI, and if it has loaded + * a resource that is classified as a tracker. + * + * This is a helper attribute which returns the same value of + * (thirdPartyClassificationFlags & CLASSIFIED_ANY_BASIC_TRACKING) or + * (thirdPartyClassificationFlags & CLASSIFIED_ANY_STRICT_TRACKING) or + * (thirdPartyClassificationFlags & CLASSIFIED_ANY_SOCIAL_TRACKING) + */ + boolean isThirdPartyTrackingResource(); + +%{ C++ + inline bool IsThirdPartyTrackingResource() + { + bool value = false; + if (NS_SUCCEEDED(IsThirdPartyTrackingResource(&value)) && value) { + return true; + } + return false; + } +%} + + /** + * Returns true if the channel has loaded a 3rd party resource that is + * classified as a social tracker. + * + * This is a helper attribute which returns the same value of + * (classificationFlags & CLASSIFIED_ANY_SOCIAL_TRACKING) + * + * Note that top-level channels could be marked as tracking + * resources. In order to identify third-party social tracking resources + * specifically, check the flags manually or add a new helper here. + */ + boolean isThirdPartySocialTrackingResource(); + +%{ C++ + inline bool IsThirdPartySocialTrackingResource() + { + bool value = false; + if (NS_SUCCEEDED(IsThirdPartySocialTrackingResource(&value)) && value) { + return true; + } + return false; + } +%} +}; diff --git a/netwerk/base/nsIContentSniffer.idl b/netwerk/base/nsIContentSniffer.idl new file mode 100644 index 0000000000..f9052b8e60 --- /dev/null +++ b/netwerk/base/nsIContentSniffer.idl @@ -0,0 +1,35 @@ +/* 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 "nsISupports.idl" + +interface nsIRequest; + +/** + * Content sniffer interface. Components implementing this interface can + * determine a MIME type from a chunk of bytes. + */ +[scriptable, uuid(a5772d1b-fc63-495e-a169-96e8d3311af0)] +interface nsIContentSniffer : nsISupports +{ + /** + * Given a chunk of data, determines a MIME type. Information from the given + * request may be used in order to make a better decision. + * + * @param aRequest The request where this data came from. May be null. + * @param aData Data to check + * @param aLength Length of the data + * + * @return The content type + * + * @throw NS_ERROR_NOT_AVAILABLE if no MIME type could be determined. + * + * @note Implementations should consider the request read-only. Especially, + * they should not attempt to set the content type property that subclasses of + * nsIRequest might offer. + */ + ACString getMIMETypeFromContent(in nsIRequest aRequest, + [const,array,size_is(aLength)] in octet aData, + in unsigned long aLength); +}; diff --git a/netwerk/base/nsIDHCPClient.idl b/netwerk/base/nsIDHCPClient.idl new file mode 100644 index 0000000000..1d986ebd52 --- /dev/null +++ b/netwerk/base/nsIDHCPClient.idl @@ -0,0 +1,19 @@ +/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +/** + * This interface allows the proxy code to access the DHCP Options in a platform-specific way + */ +[scriptable, uuid(aee75dc0-be1a-46b9-9e0c-31a6899c175c)] +interface nsIDHCPClient : nsISupports +{ + + /** + * returns the DHCP Option designated by the option parameter + */ + ACString getOption(in uint8_t option); +}; diff --git a/netwerk/base/nsIDashboard.idl b/netwerk/base/nsIDashboard.idl new file mode 100644 index 0000000000..ae80a9e458 --- /dev/null +++ b/netwerk/base/nsIDashboard.idl @@ -0,0 +1,64 @@ +/* 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 "nsISupports.idl" + +/* A JavaScript callback function that takes a JSON as its parameter. + * The returned JSON contains arrays with data + */ +[scriptable, function, uuid(19d7f24f-a95a-4fd9-87e2-d96e9e4b1f6d)] +interface nsINetDashboardCallback : nsISupports +{ + void onDashboardDataAvailable(in jsval data); +}; + +/* The dashboard service. + * The async API returns JSONs, which hold arrays with the required info. + * Only one request of each type may be pending at any time. + */ +[scriptable, uuid(c79eb3c6-091a-45a6-8544-5a8d1ab79537)] +interface nsIDashboard : nsISupports +{ + /* Arrays: host, port, tcp, active, socksent, sockreceived + * Values: sent, received */ + void requestSockets(in nsINetDashboardCallback cb); + + /* Arrays: host, port, spdy, ssl + * Array of arrays: active, idle */ + void requestHttpConnections(in nsINetDashboardCallback cb); + + /* Arrays: hostport, encrypted, msgsent, msgreceived, sentsize, receivedsize */ + void requestWebsocketConnections(in nsINetDashboardCallback cb); + + /* Arrays: hostname, family, hostaddr, expiration */ + void requestDNSInfo(in nsINetDashboardCallback cb); + + /* aProtocol: a transport layer protocol: + * ex: "ssl", "tcp", default is "tcp". + * aHost: the host's name + * aPort: the port which the connection will open on + * aTimeout: the timespan before the connection will be timed out */ + void requestConnection(in ACString aHost, in unsigned long aPort, + in string aProtocol, in unsigned long aTimeout, + in nsINetDashboardCallback cb); + + /* When true, the service will log websocket events */ + attribute boolean enableLogging; + + /* DNS resolver for host name + * aHost: host name */ + void requestDNSLookup(in ACString aHost, in nsINetDashboardCallback cb); + + /* Resolve HTTPS RRs for host name + * aHost: host name */ + void requestDNSHTTPSRRLookup(in ACString aHost, + in nsINetDashboardCallback cb); + + /** + * Asyncly returns stats regarding the "Race Cache With Network" feature. + */ + void requestRcwnStats(in nsINetDashboardCallback cb); + + AUTF8String getLogPath(); +}; diff --git a/netwerk/base/nsIDashboardEventNotifier.idl b/netwerk/base/nsIDashboardEventNotifier.idl new file mode 100644 index 0000000000..d84fd2ed4f --- /dev/null +++ b/netwerk/base/nsIDashboardEventNotifier.idl @@ -0,0 +1,23 @@ +/* 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 "nsISupports.idl" + +[builtinclass, uuid(24fdfcbe-54cb-4997-8392-3c476126ea3b)] +interface nsIDashboardEventNotifier : nsISupports +{ + /* These methods are called to register a websocket event with the dashboard + * + * A host is identified by the (aHost, aSerial) pair. + * aHost: the host's name: example.com + * aSerial: a number that uniquely identifies the websocket + * + * aEncrypted: if the connection is encrypted + * aLength: the length of the message in bytes + */ + void addHost(in ACString aHost, in unsigned long aSerial, in boolean aEncrypted); + void removeHost(in ACString aHost, in unsigned long aSerial); + void newMsgSent(in ACString aHost, in unsigned long aSerial, in unsigned long aLength); + void newMsgReceived(in ACString aHost, in unsigned long aSerial, in unsigned long aLength); +}; diff --git a/netwerk/base/nsIDeprecationWarner.idl b/netwerk/base/nsIDeprecationWarner.idl new file mode 100644 index 0000000000..72303b8156 --- /dev/null +++ b/netwerk/base/nsIDeprecationWarner.idl @@ -0,0 +1,23 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +/** + * Interface for warning about deprecated operations. Consumers should + * attach this interface to the channel's notification callbacks/loadgroup. + */ +[uuid(665c5124-2c52-41ba-ae72-2393f8e76c25)] +interface nsIDeprecationWarner : nsISupports +{ + /** + * Issue a deprecation warning. + * + * @param aWarning a warning code as declared in nsDeprecatedOperationList.h. + * @param aAsError optional boolean flag indicating whether the warning + * should be treated as an error. + */ + void issueWarning(in uint32_t aWarning, [optional] in bool aAsError); +}; diff --git a/netwerk/base/nsIDownloader.idl b/netwerk/base/nsIDownloader.idl new file mode 100644 index 0000000000..738940b4bb --- /dev/null +++ b/netwerk/base/nsIDownloader.idl @@ -0,0 +1,51 @@ +/* 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 "nsIStreamListener.idl" + +interface nsIFile; +interface nsIDownloadObserver; + +/** + * nsIDownloader + * + * A downloader is a special implementation of a nsIStreamListener that will + * make the contents of the stream available as a file. This may utilize the + * disk cache as an optimization to avoid an extra copy of the data on disk. + * The resulting file is valid from the time the downloader completes until + * the last reference to the downloader is released. + */ +[scriptable, uuid(fafe41a9-a531-4d6d-89bc-588a6522fb4e)] +interface nsIDownloader : nsIStreamListener +{ + /** + * Initialize this downloader + * + * @param observer + * the observer to be notified when the download completes. + * @param downloadLocation + * the location where the stream contents should be written. + * if null, the downloader will select a location and the + * resulting file will be deleted (or otherwise made invalid) + * when the downloader object is destroyed. if an explicit + * download location is specified then the resulting file will + * not be deleted, and it will be the callers responsibility + * to keep track of the file, etc. + */ + void init(in nsIDownloadObserver observer, + in nsIFile downloadLocation); +}; + +[scriptable, uuid(44b3153e-a54e-4077-a527-b0325e40924e)] +interface nsIDownloadObserver : nsISupports +{ + /** + * Called to signal a download that has completed. + */ + void onDownloadComplete(in nsIDownloader downloader, + in nsIRequest request, + in nsISupports ctxt, + in nsresult status, + in nsIFile result); +}; diff --git a/netwerk/base/nsIEncodedChannel.idl b/netwerk/base/nsIEncodedChannel.idl new file mode 100644 index 0000000000..a7571a0a92 --- /dev/null +++ b/netwerk/base/nsIEncodedChannel.idl @@ -0,0 +1,55 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +interface nsIUTF8StringEnumerator; +interface nsIStreamListener; +interface nsISupports; + +/** + * A channel interface which allows special handling of encoded content + */ + +[scriptable, uuid(29c29ce6-8ce4-45e6-8d60-36c8fa3e255b)] +interface nsIEncodedChannel : nsISupports +{ + /** + * This attribute holds the MIME types corresponding to the content + * encodings on the channel. The enumerator returns nsISupportsCString + * objects. The first one corresponds to the outermost encoding on the + * channel and then we work our way inward. "identity" is skipped and not + * represented on the list. Unknown encodings make the enumeration stop. + * If you want the actual Content-Encoding value, use + * getResponseHeader("Content-Encoding"). + * + * When there is no Content-Encoding header, this property is null. + * + * Modifying the Content-Encoding header on the channel will cause + * this enumerator to have undefined behavior. Don't do it. + * + * Also note that contentEncodings only exist during or after OnStartRequest. + * Calling contentEncodings before OnStartRequest is an error. + */ + readonly attribute nsIUTF8StringEnumerator contentEncodings; + + /** + * This attribute controls whether or not content conversion should be + * done per the Content-Encoding response header. applyConversion can only + * be set before or during OnStartRequest. Calling this during + * OnDataAvailable is an error. + * + * TRUE by default. + */ + attribute boolean applyConversion; + + /** + * This function will start converters if they are available. + * aNewNextListener will be nullptr if no converter is available. + */ + void doApplyContentConversions(in nsIStreamListener aNextListener, + out nsIStreamListener aNewNextListener, + in nsISupports aCtxt); +}; diff --git a/netwerk/base/nsIExternalProtocolHandler.idl b/netwerk/base/nsIExternalProtocolHandler.idl new file mode 100644 index 0000000000..6f86dbb05a --- /dev/null +++ b/netwerk/base/nsIExternalProtocolHandler.idl @@ -0,0 +1,17 @@ +/* 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 "nsIProtocolHandler.idl" + +[scriptable, uuid(0e61f3b2-34d7-4c79-bfdc-4860bc7341b7)] +interface nsIExternalProtocolHandler: nsIProtocolHandler +{ + /** + * This method checks if the external handler exists for a given scheme. + * + * @param scheme external scheme. + * @return TRUE if the external handler exists for the input scheme, FALSE otherwise. + */ + boolean externalAppExistsForScheme(in ACString scheme); +}; diff --git a/netwerk/base/nsIFileStreams.idl b/netwerk/base/nsIFileStreams.idl new file mode 100644 index 0000000000..4b704493ea --- /dev/null +++ b/netwerk/base/nsIFileStreams.idl @@ -0,0 +1,238 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsIInputStream.idl" +#include "nsIOutputStream.idl" + +interface nsIEventTarget; +interface nsIFile; +interface nsIFileMetadataCallback; + +%{C++ +struct PRFileDesc; +%} + +[ptr] native PRFileDescPtr(PRFileDesc); + +/** + * An input stream that allows you to read from a file. + */ +[scriptable, uuid(e3d56a20-c7ec-11d3-8cda-0060b0fc14a3)] +interface nsIFileInputStream : nsIInputStream +{ + /** + * @param file file to read from + * @param ioFlags file open flags listed in prio.h (see + * PR_Open documentation) or -1 to open the + * file in default mode (PR_RDONLY). + * @param perm file mode bits listed in prio.h or -1 to + * use the default value (0) + * @param behaviorFlags flags specifying various behaviors of the class + * (see enumerations in the class) + */ + void init(in nsIFile file, in long ioFlags, in long perm, + in long behaviorFlags); + + /** + * If this is set, the file will close automatically when the end of the + * file is reached. + */ + const long CLOSE_ON_EOF = 1<<2; + + /** + * If this is set, the file will be reopened whenever we reach the start of + * the file, either by doing a Seek(0, NS_SEEK_CUR), or by doing a relative + * seek that happen to reach the beginning of the file. If the file is + * already open and the seek occurs, it will happen naturally. (The file + * will only be reopened if it is closed for some reason.) + */ + const long REOPEN_ON_REWIND = 1<<3; + + /** + * If this is set, the file will be opened (i.e., a call to + * PR_Open done) only when we do an actual operation on the stream, + * or more specifically, when one of the following is called: + * - Seek + * - Tell + * - SetEOF + * - Available + * - Read + * - ReadLine + * + * DEFER_OPEN is useful if we use the stream on a background + * thread, so that the opening and possible |stat|ing of the file + * happens there as well. + * + * @note Using this flag results in the file not being opened + * during the call to Init. This means that any errors that might + * happen when this flag is not set would happen during the + * first read. Also, the file is not locked when Init is called, + * so it might be deleted before we try to read from it. + */ + const long DEFER_OPEN = 1<<4; + + /** + * This flag has no effect and is totally ignored on any platform except + * Windows since this is the default behavior on POSIX systems. On Windows + * if this flag is set then the stream is opened in a special mode that + * allows the OS to delete the file from disk just like POSIX. + */ + const long SHARE_DELETE = 1<<5; +}; + +/** + * An output stream that lets you stream to a file. + */ +[scriptable, uuid(e734cac9-1295-4e6f-9684-3ac4e1f91063)] +interface nsIFileOutputStream : nsIOutputStream +{ + /** + * @param file file to write to + * @param ioFlags file open flags listed in prio.h (see + * PR_Open documentation) or -1 to open the + * file in default mode (PR_WRONLY | + * PR_CREATE_FILE | PR_TRUNCATE) + * @param perm file mode bits listed in prio.h or -1 to + * use the default permissions (0664) + * @param behaviorFlags flags specifying various behaviors of the class + * (currently none supported) + */ + void init(in nsIFile file, in long ioFlags, in long perm, + in long behaviorFlags); + + /** + * @param length asks the operating system to allocate storage for + * this file of at least |length| bytes long, and + * set the file length to the corresponding size. + * @throws NS_ERROR_FAILURE if the preallocation fails. + * @throws NS_ERROR_NOT_INITIALIZED if the file is not opened. + */ + [noscript] void preallocate(in long long length); + + /** + * See the same constant in nsIFileInputStream. The deferred open will + * be performed when one of the following is called: + * - Seek + * - Tell + * - SetEOF + * - Write + * - Flush + * + * @note Using this flag results in the file not being opened + * during the call to Init. This means that any errors that might + * happen when this flag is not set would happen during the + * first write, and if the file is to be created, then it will not + * appear on the disk until the first write. + */ + const long DEFER_OPEN = 1<<0; +}; + +/** + * A stream that allows you to read from a file or stream to a file. + */ +[scriptable, uuid(82cf605a-8393-4550-83ab-43cd5578e006)] +interface nsIFileStream : nsISupports +{ + /** + * @param file file to read from or stream to + * @param ioFlags file open flags listed in prio.h (see + * PR_Open documentation) or -1 to open the + * file in default mode (PR_RDWR). + * @param perm file mode bits listed in prio.h or -1 to + * use the default value (0) + * @param behaviorFlags flags specifying various behaviors of the class + * (see enumerations in the class) + */ + void init(in nsIFile file, in long ioFlags, in long perm, + in long behaviorFlags); + + /** + * See the same constant in nsIFileInputStream. The deferred open will + * be performed when one of the following is called: + * - Seek + * - Tell + * - SetEOF + * - Available + * - Read + * - Flush + * - Write + * - GetSize + * - GetLastModified + * + * @note Using this flag results in the file not being opened + * during the call to Init. This means that any errors that might + * happen when this flag is not set would happen during the + * first read or write. The file is not locked when Init is called, + * so it might be deleted before we try to read from it and if the + * file is to be created, then it will not appear on the disk until + * the first write. + */ + const long DEFER_OPEN = 1<<0; +}; + +/** + * An interface that allows you to get some metadata like file size and + * file last modified time. These methods and attributes can throw + * NS_BASE_STREAM_WOULD_BLOCK in case the informations are not available yet. + * If this happens, consider the use of nsIAsyncFileMetadata. + * + * If using nsIAsyncFileMetadata, you should retrieve any data via this + * interface before taking any action that might consume the underlying stream. + * For example, once Available(), Read(), or nsIAsyncInputStream::AsyncWait() + * are invoked, these methods may return NS_BASE_STREAM_CLOSED. This will + * happen when using RemoteLazyInputStream with an underlying file stream, for + * example. + */ +[scriptable, uuid(07f679e4-9601-4bd1-b510-cd3852edb881)] +interface nsIFileMetadata : nsISupports +{ + /** + * File size in bytes. + */ + readonly attribute long long size; + + /** + * File last modified time in milliseconds from midnight (00:00:00), + * January 1, 1970 Greenwich Mean Time (GMT). + */ + readonly attribute long long lastModified; + + /** + * The internal file descriptor. It can be used for memory mapping of the + * underlying file. Please use carefully! If this returns + * NS_BASE_STREAM_WOULD_BLOCK, consider the use of nsIAsyncFileMetadata. + */ + [noscript] PRFileDescPtr getFileDescriptor(); +}; + +[scriptable, uuid(de15b80b-29ba-4b7f-9220-a3d75b17ae8c)] +interface nsIAsyncFileMetadata : nsIFileMetadata +{ + /** + * Asynchronously wait for the object to be ready. + * + * @param aCallback The callback will be used when the stream is ready to + * return File metadata. Use a nullptr to cancel a + * previous operation. + * + * @param aEventTarget The event target where aCallback will be executed. + * If aCallback is passed, aEventTarget cannot be null. + */ + void asyncFileMetadataWait(in nsIFileMetadataCallback aCallback, + in nsIEventTarget aEventTarget); +}; + +/** + * This is a companion interface for + * nsIAsyncFileMetadata::asyncFileMetadataWait. + */ +[function, scriptable, uuid(d01c7ead-7ba3-4726-b399-618ec8ec7057)] +interface nsIFileMetadataCallback : nsISupports +{ + /** + * Called to indicate that the nsIFileMetadata object is ready. + */ + void onFileMetadataReady(in nsIAsyncFileMetadata aObject); +}; diff --git a/netwerk/base/nsIFileURL.idl b/netwerk/base/nsIFileURL.idl new file mode 100644 index 0000000000..3c97a2e3af --- /dev/null +++ b/netwerk/base/nsIFileURL.idl @@ -0,0 +1,42 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsIURL.idl" + +interface nsIFile; +interface nsIURIMutator; + +/** + * nsIFileURL provides access to the underlying nsIFile object corresponding to + * an URL. The URL scheme need not be file:, since other local protocols may + * map URLs to files (e.g., resource:). + */ +[scriptable, builtinclass, uuid(e91ac988-27c2-448b-b1a1-3822e1ef1987)] +interface nsIFileURL : nsIURL +{ + /** + * Get the nsIFile corresponding to this URL. + * + * - Returns a reference to an immutable object. Callers must clone + * before attempting to modify the returned nsIFile object. NOTE: this + * constraint might not be enforced at runtime, so beware!! + */ + readonly attribute nsIFile file; +}; + +[scriptable, builtinclass, uuid(a588b6f2-d2b9-4024-84c7-be3368546b57)] +interface nsIFileURLMutator : nsISupports +{ + /* + * - Marks the inner URI implementation as one that supports nsIFileURL. + */ + [must_use, noscript] void markFileURL(); + + /* + * - Setter clones the nsIFile object (allowing the caller to safely modify + * the nsIFile object after setting it on this interface). + */ + [must_use, noscript] void setFile(in nsIFile aFile); +}; diff --git a/netwerk/base/nsIForcePendingChannel.idl b/netwerk/base/nsIForcePendingChannel.idl new file mode 100644 index 0000000000..b915fd8327 --- /dev/null +++ b/netwerk/base/nsIForcePendingChannel.idl @@ -0,0 +1,22 @@ +/* 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 "nsISupports.idl" + +/** + * nsIForcePending interface exposes a function that enables overwriting of the normal + * behavior for the channel's IsPending(), forcing 'true' to be returned. + */ + +[noscript, uuid(2ac3e1ca-049f-44c3-a519-f0681f51e9b1)] +interface nsIForcePendingChannel : nsISupports +{ + +/** + * forcePending(true) overrides the normal behavior for the + * channel's IsPending(), forcing 'true' to be returned. A call to + * forcePending(false) reverts IsPending() back to normal behavior. + */ + void forcePending(in boolean aForcePending); +}; diff --git a/netwerk/base/nsIFormPOSTActionChannel.idl b/netwerk/base/nsIFormPOSTActionChannel.idl new file mode 100644 index 0000000000..870886390c --- /dev/null +++ b/netwerk/base/nsIFormPOSTActionChannel.idl @@ -0,0 +1,17 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "nsIUploadChannel.idl" + +/** + * nsIFormPOSTActionChannel + * + * Channel classes that want to be allowed for HTML form POST action must + * implement this interface. + */ +[scriptable, uuid(fc826b53-0db8-42b4-aa6a-5dd2cfca52a4)] +interface nsIFormPOSTActionChannel : nsIUploadChannel +{ +}; diff --git a/netwerk/base/nsIHttpAuthenticatorCallback.idl b/netwerk/base/nsIHttpAuthenticatorCallback.idl new file mode 100644 index 0000000000..534f95ad38 --- /dev/null +++ b/netwerk/base/nsIHttpAuthenticatorCallback.idl @@ -0,0 +1,31 @@ +/* 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 "nsISupports.idl" + +[builtinclass, uuid(d989cb03-e446-4086-b9e6-46842cb97bd5)] +interface nsIHttpAuthenticatorCallback : nsISupports +{ + /** + * Authentication data for a header is available. + * + * @param aCreds + * Credentials which were obtained asynchonously. + * @param aFlags + * Flags set by asynchronous call. + * @param aResult + * Result status of credentials generation + * @param aSessionState + * Modified session state to be passed to caller + * @param aContinuationState + * Modified continuation state to be passed to caller + */ + void onCredsGenerated(in string aCreds, + in unsigned long aFlags, + in nsresult aResult, + in nsISupports aSessionsState, + in nsISupports aContinuationState); + +}; + diff --git a/netwerk/base/nsIHttpPushListener.idl b/netwerk/base/nsIHttpPushListener.idl new file mode 100644 index 0000000000..f44605c000 --- /dev/null +++ b/netwerk/base/nsIHttpPushListener.idl @@ -0,0 +1,36 @@ +/* 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 "nsISupports.idl" +interface nsIHttpChannel; + +/** + * nsIHttpPushListener + * + * Used for triggering when a HTTP/2 push is received. + * + */ +[scriptable, uuid(0d6ce59c-ad5d-4520-b4d3-09664868f279)] +interface nsIHttpPushListener : nsISupports +{ + /** + * When provided as a notificationCallback to an httpChannel, this.onPush() + * will be invoked when there is a >= Http2 push to that + * channel. The push may be in progress. + * + * The consumer must start the new channel in the usual way by calling + * pushChannel.AsyncOpen with a nsIStreamListener object that + * will receive the normal sequence of OnStartRequest(), + * 0 to N OnDataAvailable(), and onStopRequest(). + * + * The new channel can be canceled after the AsyncOpen if it is not wanted. + * + * @param associatedChannel + * the monitor channel that was recieved on + * @param pushChannel + * a channel to the resource which is being pushed + */ + void onPush(in nsIHttpChannel associatedChannel, + in nsIHttpChannel pushChannel); +}; diff --git a/netwerk/base/nsIIOService.idl b/netwerk/base/nsIIOService.idl new file mode 100644 index 0000000000..e162432fb1 --- /dev/null +++ b/netwerk/base/nsIIOService.idl @@ -0,0 +1,300 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" +#include "nsIContentPolicy.idl" + +interface nsIProtocolHandler; +interface nsIChannel; +interface nsIURI; +interface nsIFile; +interface nsIPrincipal; +interface nsILoadInfo; + +webidl Node; + +%{C++ +#include "mozilla/Maybe.h" + +namespace mozilla { +namespace dom { +class ClientInfo; +class ServiceWorkerDescriptor; +} // namespace dom +} // namespace mozilla +%} + +[ref] native const_MaybeClientInfoRef(const mozilla::Maybe<mozilla::dom::ClientInfo>); +[ref] native const_MaybeServiceWorkerDescriptorRef(const mozilla::Maybe<mozilla::dom::ServiceWorkerDescriptor>); + +/** + * nsIIOService provides a set of network utility functions. This interface + * duplicates many of the nsIProtocolHandler methods in a protocol handler + * independent way (e.g., NewURI inspects the scheme in order to delegate + * creation of the new URI to the appropriate protocol handler). nsIIOService + * also provides a set of URL parsing utility functions. These are provided + * as a convenience to the programmer and in some cases to improve performance + * by eliminating intermediate data structures and interfaces. + */ +[scriptable, builtinclass, uuid(4286de5a-b2ea-446f-8f70-e2a461f42694)] +interface nsIIOService : nsISupports +{ + /** + * Returns a protocol handler for a given URI scheme. + * + * @param aScheme the URI scheme + * @return reference to corresponding nsIProtocolHandler + */ + nsIProtocolHandler getProtocolHandler(in string aScheme); + + /** + * Returns the protocol flags for a given scheme. + * + * @param aScheme the URI scheme + * @return value of corresponding nsIProtocolHandler::protocolFlags + */ + unsigned long getProtocolFlags(in string aScheme); + + /** + * This method constructs a new URI by determining the scheme of the + * URI spec, and then delegating the construction of the URI to the + * protocol handler for that scheme. QueryInterface can be used on + * the resulting URI object to obtain a more specific type of URI. + * + * @see nsIProtocolHandler::newURI + */ + nsIURI newURI(in AUTF8String aSpec, + [optional] in string aOriginCharset, + [optional] in nsIURI aBaseURI); + + /** + * This method constructs a new URI from a nsIFile. + * + * @param aFile specifies the file path + * @return reference to a new nsIURI object + * + * Note: in the future, for perf reasons we should allow + * callers to specify whether this is a file or directory by + * splitting this into newDirURI() and newActualFileURI(). + */ + nsIURI newFileURI(in nsIFile aFile); + + /** + * Converts an internal URI (e.g. one that has a username and password in + * it) into one which we can expose to the user, for example on the URL bar. + * + * @param aURI The URI to be converted. + * @return nsIURI The converted, exposable URI. + */ + nsIURI createExposableURI(in nsIURI aURI); + + /** + * Creates a channel for a given URI. + * + * @param aURI + * nsIURI from which to make a channel + * @param aLoadingNode + * @param aLoadingPrincipal + * @param aTriggeringPrincipal + * @param aSecurityFlags + * @param aContentPolicyType + * These will be used as values for the nsILoadInfo object on the + * created channel. For details, see nsILoadInfo in nsILoadInfo.idl + * @return reference to the new nsIChannel object + * + * Please note, if you provide both a loadingNode and a loadingPrincipal, + * then loadingPrincipal must be equal to loadingNode->NodePrincipal(). + * But less error prone is to just supply a loadingNode. + * + * Keep in mind that URIs coming from a webpage should *never* use the + * systemPrincipal as the loadingPrincipal. + */ + nsIChannel newChannelFromURI(in nsIURI aURI, + in Node aLoadingNode, + in nsIPrincipal aLoadingPrincipal, + in nsIPrincipal aTriggeringPrincipal, + in unsigned long aSecurityFlags, + in nsContentPolicyType aContentPolicyType); + + [noscript, nostdcall, notxpcom] + nsresult NewChannelFromURIWithClientAndController(in nsIURI aURI, + in Node aLoadingNode, + in nsIPrincipal aLoadingPrincipal, + in nsIPrincipal aTriggeringPrincipal, + in const_MaybeClientInfoRef aLoadingClientInfo, + in const_MaybeServiceWorkerDescriptorRef aController, + in unsigned long aSecurityFlags, + in nsContentPolicyType aContentPolicyType, + in unsigned long aSandboxFlags, + out nsIChannel aResult); + + /** + * Equivalent to newChannelFromURI(aURI, aLoadingNode, ...) + */ + nsIChannel newChannelFromURIWithLoadInfo(in nsIURI aURI, + in nsILoadInfo aLoadInfo); + + /** + * Equivalent to newChannelFromURI(newURI(...)) + */ + nsIChannel newChannel(in AUTF8String aSpec, + in string aOriginCharset, + in nsIURI aBaseURI, + in Node aLoadingNode, + in nsIPrincipal aLoadingPrincipal, + in nsIPrincipal aTriggeringPrincipal, + in unsigned long aSecurityFlags, + in nsContentPolicyType aContentPolicyType); + + /** + * Returns true if networking is in "offline" mode. When in offline mode, + * attempts to access the network will fail (although this does not + * necessarily correlate with whether there is actually a network + * available -- that's hard to detect without causing the dialer to + * come up). + * + * Changing this fires observer notifications ... see below. + */ + attribute boolean offline; + + /** + * Returns false if there are no interfaces for a network request + */ + readonly attribute boolean connectivity; + + /** + * Checks if a port number is banned. This involves consulting a list of + * unsafe ports, corresponding to network services that may be easily + * exploitable. If the given port is considered unsafe, then the protocol + * handler (corresponding to aScheme) will be asked whether it wishes to + * override the IO service's decision to block the port. This gives the + * protocol handler ultimate control over its own security policy while + * ensuring reasonable, default protection. + * + * @see nsIProtocolHandler::allowPort + */ + boolean allowPort(in long aPort, in string aScheme); + + /** + * Utility to extract the scheme from a URL string, consistently and + * according to spec (see RFC 2396). + * + * NOTE: Most URL parsing is done via nsIURI, and in fact the scheme + * can also be extracted from a URL string via nsIURI. This method + * is provided purely as an optimization. + * + * @param aSpec the URL string to parse + * @return URL scheme, lowercase + * + * @throws NS_ERROR_MALFORMED_URI if URL string is not of the right form. + */ + ACString extractScheme(in AUTF8String urlString); + + /** + * Checks if a URI host is a local IPv4 or IPv6 address literal. + * + * @param nsIURI the URI that contains the hostname to check + * @return true if the URI hostname is a local IP address + */ + boolean hostnameIsLocalIPAddress(in nsIURI aURI); + + /** + * Checks if a URI host is a shared IPv4 address literal. + * + * @param nsIURI the URI that contains the hostname to check + * @return true if the URI hostname is a shared IP address + */ + boolean hostnameIsSharedIPAddress(in nsIURI aURI); + + /** + * While this is set, IOService will monitor an nsINetworkLinkService + * (if available) and set its offline status to "true" whenever + * isLinkUp is false. + * + * Applications that want to control changes to the IOService's offline + * status should set this to false, watch for network:link-status-changed + * broadcasts, and change nsIIOService::offline as they see fit. Note + * that this means during application startup, IOService may be offline + * if there is no link, until application code runs and can turn off + * this management. + */ + attribute boolean manageOfflineStatus; + + /** + * Creates a channel for a given URI. + * + * @param aURI + * nsIURI from which to make a channel + * @param aProxyURI + * nsIURI to use for proxy resolution. Can be null in which + * case aURI is used + * @param aProxyFlags flags from nsIProtocolProxyService to use + * when resolving proxies for this new channel + * @param aLoadingNode + * @param aLoadingPrincipal + * @param aTriggeringPrincipal + * @param aSecurityFlags + * @param aContentPolicyType + * These will be used as values for the nsILoadInfo object on the + * created channel. For details, see nsILoadInfo in nsILoadInfo.idl + * @return reference to the new nsIChannel object + * + * Please note, if you provide both a loadingNode and a loadingPrincipal, + * then loadingPrincipal must be equal to loadingNode->NodePrincipal(). + * But less error prone is to just supply a loadingNode. + */ + nsIChannel newChannelFromURIWithProxyFlags(in nsIURI aURI, + in nsIURI aProxyURI, + in unsigned long aProxyFlags, + in Node aLoadingNode, + in nsIPrincipal aLoadingPrincipal, + in nsIPrincipal aTriggeringPrincipal, + in unsigned long aSecurityFlags, + in nsContentPolicyType aContentPolicyType); + + /** + * Return true if socket process is launched. + */ + readonly attribute boolean socketProcessLaunched; +}; + +%{C++ +/** + * We send notifications through nsIObserverService with topic + * NS_IOSERVICE_GOING_OFFLINE_TOPIC and data NS_IOSERVICE_OFFLINE + * when 'offline' has changed from false to true, and we are about + * to shut down network services such as DNS. When those + * services have been shut down, we send a notification with + * topic NS_IOSERVICE_OFFLINE_STATUS_TOPIC and data + * NS_IOSERVICE_OFFLINE. + * + * When 'offline' changes from true to false, then after + * network services have been restarted, we send a notification + * with topic NS_IOSERVICE_OFFLINE_STATUS_TOPIC and data + * NS_IOSERVICE_ONLINE. + */ +#define NS_IOSERVICE_GOING_OFFLINE_TOPIC "network:offline-about-to-go-offline" +#define NS_IOSERVICE_OFFLINE_STATUS_TOPIC "network:offline-status-changed" +#define NS_IOSERVICE_OFFLINE "offline" +#define NS_IOSERVICE_ONLINE "online" + +%} + +[builtinclass, uuid(6633c0bf-d97a-428f-8ece-cb6a655fb95a)] +interface nsIIOServiceInternal : nsISupports +{ + /** + * This is an internal method that should only be called from ContentChild + * in order to pass the connectivity state from the chrome process to the + * content process. It throws if called outside the content process. + */ + void SetConnectivity(in boolean connectivity); + + /** + * An internal method to asynchronously run our notifications that happen + * when we wake from sleep + */ + void NotifyWakeup(); +}; diff --git a/netwerk/base/nsIIncrementalDownload.idl b/netwerk/base/nsIIncrementalDownload.idl new file mode 100644 index 0000000000..3ae363c488 --- /dev/null +++ b/netwerk/base/nsIIncrementalDownload.idl @@ -0,0 +1,109 @@ +/* -*- 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 "nsIRequest.idl" + +interface nsIURI; +interface nsIFile; +interface nsIRequestObserver; + +/** + * An incremental download object attempts to fetch a file piecemeal over time + * in an effort to minimize network bandwidth usage. + * + * Canceling a background download does not cause the file on disk to be + * deleted. + */ +[scriptable, uuid(6687823f-56c4-461d-93a1-7f6cb7dfbfba)] +interface nsIIncrementalDownload : nsIRequest +{ + /** + * Initialize the incremental download object. If the destination file + * already exists, then only the remaining portion of the file will be + * fetched. + * + * NOTE: The downloader will create the destination file if it does not + * already exist. It will create the file with the permissions 0600 if + * needed. To affect the permissions of the file, consumers of this + * interface may create an empty file at the specified destination prior to + * starting the incremental download. + * + * NOTE: Since this class may create a temporary file at the specified + * destination, it is advisable for the consumer of this interface to specify + * a file name for the destination that would not tempt the user into + * double-clicking it. For example, it might be wise to append a file + * extension like ".part" to the end of the destination to protect users from + * accidentally running "blah.exe" before it is a complete file. + * + * @param uri + * The URI to fetch. + * @param destination + * The location where the file is to be stored. + * @param chunkSize + * The size of the chunks to fetch. A non-positive value results in + * the default chunk size being used. + * @param intervalInSeconds + * The amount of time to wait between fetching chunks. Pass a + * negative to use the default interval, or 0 to fetch the remaining + * part of the file in one chunk. + */ + void init(in nsIURI uri, in nsIFile destination, in long chunkSize, + in long intervalInSeconds); + + /** + * The URI being fetched. + */ + readonly attribute nsIURI URI; + + /** + * The URI being fetched after any redirects have been followed. This + * attribute is set just prior to calling OnStartRequest on the observer + * passed to the start method. + */ + readonly attribute nsIURI finalURI; + + /** + * The file where the download is being written. + */ + readonly attribute nsIFile destination; + + /** + * The total number of bytes for the requested file. This attribute is set + * just prior to calling OnStartRequest on the observer passed to the start + * method. + * + * This attribute has a value of -1 if the total size is unknown. + */ + readonly attribute long long totalSize; + + /** + * The current number of bytes downloaded so far. This attribute is set just + * prior to calling OnStartRequest on the observer passed to the start + * method. + * + * This attribute has a value of -1 if the current size is unknown. + */ + readonly attribute long long currentSize; + + /** + * Start the incremental download. + * + * @param observer + * An observer to be notified of various events. OnStartRequest is + * called when finalURI and totalSize have been determined or when an + * error occurs. OnStopRequest is called when the file is completely + * downloaded or when an error occurs. If this object implements + * nsIProgressEventSink, then its OnProgress method will be called as + * data is written to the destination file. If this object implements + * nsIInterfaceRequestor, then it will be assigned as the underlying + * channel's notification callbacks, which allows it to provide a + * nsIAuthPrompt implementation if needed by the channel, for example. + * @param ctxt + * User defined object forwarded to the observer's methods. + */ + void start(in nsIRequestObserver observer, + in nsISupports ctxt); +}; diff --git a/netwerk/base/nsIIncrementalStreamLoader.idl b/netwerk/base/nsIIncrementalStreamLoader.idl new file mode 100644 index 0000000000..60aa9cfef5 --- /dev/null +++ b/netwerk/base/nsIIncrementalStreamLoader.idl @@ -0,0 +1,100 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "nsIStreamListener.idl" + +interface nsIRequest; +interface nsIIncrementalStreamLoader; + +[scriptable, uuid(07c3d2cc-5454-4618-9f4f-cd93de9504a4)] +interface nsIIncrementalStreamLoaderObserver : nsISupports +{ + /** + * Called when new data has arrived on the stream. + * + * @param loader the stream loader that loaded the stream. + * @param ctxt the context parameter of the underlying channel + * @param dataLength the length of the new data received + * @param data the contents of the new data received. + * + * This method will always be called asynchronously by the + * nsIIncrementalStreamLoader involved, on the thread that called the + * loader's init() method. + * + * If the observer wants to not accumulate all or portional of the data in + * the internal buffer, the consumedLength shall be set to the value of + * the dataLength or less. By default the consumedLength value is assumed 0. + * The data and dataLength reflect the non-consumed data and will be + * accumulated if consumedLength is not set. + * + * In comparison with onStreamComplete(), the data buffer cannot be + * adopted if this method returns NS_SUCCESS_ADOPTED_DATA. + */ + void onIncrementalData(in nsIIncrementalStreamLoader loader, + in nsISupports ctxt, + in unsigned long dataLength, + [const,array,size_is(dataLength)] in octet data, + inout unsigned long consumedLength); + + /** + * Called when the entire stream has been loaded. + * + * @param loader the stream loader that loaded the stream. + * @param ctxt the context parameter of the underlying channel + * @param status the status of the underlying channel + * @param resultLength the length of the data loaded + * @param result the data + * + * This method will always be called asynchronously by the + * nsIIncrementalStreamLoader involved, on the thread that called the + * loader's init() method. + * + * If the observer wants to take over responsibility for the + * data buffer (result), it returns NS_SUCCESS_ADOPTED_DATA + * in place of NS_OK as its success code. The loader will then + * "forget" about the data and not free() it after + * onStreamComplete() returns; observer must call free() + * when the data is no longer required. + */ + void onStreamComplete(in nsIIncrementalStreamLoader loader, + in nsISupports ctxt, + in nsresult status, + in unsigned long resultLength, + [const,array,size_is(resultLength)] in octet result); +}; + +/** + * Asynchronously loads a channel into a memory buffer. + * + * To use this interface, first call init() with a nsIIncrementalStreamLoaderObserver + * that will be notified when the data has been loaded. Then call asyncOpen() + * on the channel with the nsIIncrementalStreamLoader as the listener. The context + * argument in the asyncOpen() call will be passed to the onStreamComplete() + * callback. + * + * XXX define behaviour for sizes >4 GB + */ +[scriptable, uuid(a023b060-ba23-431a-b449-2dd63e220554)] +interface nsIIncrementalStreamLoader : nsIStreamListener +{ + /** + * Initialize this stream loader, and start loading the data. + * + * @param aObserver + * An observer that will be notified when the data is complete. + */ + void init(in nsIIncrementalStreamLoaderObserver aObserver); + + /** + * Gets the number of bytes read so far. + */ + readonly attribute unsigned long numBytesRead; + + /** + * Gets the request that loaded this file. + * null after the request has finished loading. + */ + readonly attribute nsIRequest request; +}; diff --git a/netwerk/base/nsIInputStreamChannel.idl b/netwerk/base/nsIInputStreamChannel.idl new file mode 100644 index 0000000000..9172a2b283 --- /dev/null +++ b/netwerk/base/nsIInputStreamChannel.idl @@ -0,0 +1,64 @@ +/* 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 "nsISupports.idl" + +interface nsIInputStream; +interface nsIURI; + +/** + * nsIInputStreamChannel + * + * This interface provides methods to initialize an input stream channel. + * The input stream channel serves as a data pump for an input stream. + */ +[scriptable, uuid(ea730238-4bfd-4015-8489-8f264d05b343)] +interface nsIInputStreamChannel : nsISupports +{ + /** + * Sets the URI for this channel. This must be called before the + * channel is opened, and it may only be called once. + */ + void setURI(in nsIURI aURI); + + /** + * Get/set the content stream + * + * This stream contains the data that will be pushed to the channel's + * stream listener. If the stream is non-blocking and supports the + * nsIAsyncInputStream interface, then the stream will be read directly. + * Otherwise, the stream will be read on a background thread. + * + * This attribute must be set before the channel is opened, and it may + * only be set once. + * + * @throws NS_ERROR_IN_PROGRESS if the setter is called after the channel + * has been opened. + */ + attribute nsIInputStream contentStream; + + /** + * Get/set the srcdoc data string. When the input stream channel is + * created to load a srcdoc iframe, this is set to hold the value of the + * srcdoc attribute. + * + * This should be the same value used to create contentStream, but this is + * not checked. + * + * Changing the value of this attribute will not otherwise affect the + * functionality of the channel or input stream. + */ + attribute AString srcdocData; + + /** + * Returns true if srcdocData has been set within the channel. + */ + readonly attribute boolean isSrcdocChannel; + + /** + * The base URI to be used for the channel. Used when the base URI cannot + * be inferred by other means, for example when this is a srcdoc channel. + */ + attribute nsIURI baseURI; +}; diff --git a/netwerk/base/nsIInputStreamPump.idl b/netwerk/base/nsIInputStreamPump.idl new file mode 100644 index 0000000000..9d9cc22678 --- /dev/null +++ b/netwerk/base/nsIInputStreamPump.idl @@ -0,0 +1,66 @@ +/* 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 "nsIRequest.idl" + +interface nsIEventTarget; +interface nsIInputStream; +interface nsIStreamListener; + +/** + * nsIInputStreamPump + * + * This interface provides a means to configure and use a input stream pump + * instance. The input stream pump will asynchronously read from an input + * stream, and push data to an nsIStreamListener instance. It utilizes the + * current thread's nsIEventTarget in order to make reading from the stream + * asynchronous. A different thread can be used if the pump also implements + * nsIThreadRetargetableRequest. + * + * If the given stream supports nsIAsyncInputStream, then the stream pump will + * call the stream's AsyncWait method to drive the stream listener. Otherwise, + * the stream will be read on a background thread utilizing the stream + * transport service. More details are provided below. + */ +[scriptable, uuid(400F5468-97E7-4d2b-9C65-A82AECC7AE82)] +interface nsIInputStreamPump : nsIRequest +{ + /** + * Initialize the input stream pump. + * + * @param aStream + * contains the data to be read. if the input stream is non-blocking, + * then it will be QI'd to nsIAsyncInputStream. if the QI succeeds + * then the stream will be read directly. otherwise, it will be read + * on a background thread using the stream transport service. + * @param aSegmentSize + * if the stream transport service is used, then this parameter + * specifies the segment size for the stream transport's buffer. + * pass 0 to specify the default value. + * @param aSegmentCount + * if the stream transport service is used, then this parameter + * specifies the segment count for the stream transport's buffer. + * pass 0 to specify the default value. + * @param aCloseWhenDone + * if true, the input stream will be closed after it has been read. + * @param aMainThreadTarget + * a labeled main therad event target. + */ + void init(in nsIInputStream aStream, + in unsigned long aSegmentSize, + in unsigned long aSegmentCount, + in boolean aCloseWhenDone, + [optional] in nsIEventTarget aMainThreadTarget); + + /** + * asyncRead causes the input stream to be read in chunks and delivered + * asynchronously to the listener via OnDataAvailable. + * + * @param aListener + * receives notifications. + * @param aListenerContext + * passed to listener methods. + */ + void asyncRead(in nsIStreamListener aListener); +}; diff --git a/netwerk/base/nsILoadContextInfo.idl b/netwerk/base/nsILoadContextInfo.idl new file mode 100644 index 0000000000..bbf2b5d48a --- /dev/null +++ b/netwerk/base/nsILoadContextInfo.idl @@ -0,0 +1,86 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +%{ C++ +#include "mozilla/BasePrincipal.h" +%} +native OriginAttributesNativePtr(const mozilla::OriginAttributes*); + +interface nsILoadContext; +interface nsIDOMWindow; + +/** + * Helper interface to carry informatin about the load context + * encapsulating origin attributes and IsAnonymous, IsPrivite properties. + * It shall be used where nsILoadContext cannot be used or is not + * available. + */ + +[scriptable, builtinclass, uuid(555e2f8a-a1f6-41dd-88ca-ed4ed6b98a22)] +interface nsILoadContextInfo : nsISupports +{ + /** + * Whether the context is in a Private Browsing mode + */ + readonly attribute boolean isPrivate; + + /** + * Whether the load is initiated as anonymous + */ + readonly attribute boolean isAnonymous; + + /** + * OriginAttributes hiding all the security context attributes + */ + [implicit_jscontext] + readonly attribute jsval originAttributes; + [noscript, notxpcom, nostdcall, binaryname(OriginAttributesPtr)] + OriginAttributesNativePtr binaryOriginAttributesPtr(); + +%{C++ + /** + * De-XPCOMed getters + */ + bool IsPrivate() + { + bool pb; + GetIsPrivate(&pb); + return pb; + } + + bool IsAnonymous() + { + bool anon; + GetIsAnonymous(&anon); + return anon; + } + + bool Equals(nsILoadContextInfo *aOther) + { + return IsAnonymous() == aOther->IsAnonymous() && + *OriginAttributesPtr() == *aOther->OriginAttributesPtr(); + } +%} +}; + +/** + * Since OriginAttributes struct limits the implementation of + * nsILoadContextInfo (that needs to be thread safe) to C++, + * we need a scriptable factory to create instances of that + * interface from JS. + */ +[scriptable, uuid(c1c7023d-4318-4f99-8307-b5ccf0558793)] +interface nsILoadContextInfoFactory : nsISupports +{ + readonly attribute nsILoadContextInfo default; + readonly attribute nsILoadContextInfo private; + readonly attribute nsILoadContextInfo anonymous; + [implicit_jscontext] + nsILoadContextInfo custom(in boolean aAnonymous, in jsval aOriginAttributes); + nsILoadContextInfo fromLoadContext(in nsILoadContext aLoadContext, in boolean aAnonymous); + nsILoadContextInfo fromWindow(in nsIDOMWindow aWindow, in boolean aAnonymous); +}; diff --git a/netwerk/base/nsILoadGroup.idl b/netwerk/base/nsILoadGroup.idl new file mode 100644 index 0000000000..06e51e442b --- /dev/null +++ b/netwerk/base/nsILoadGroup.idl @@ -0,0 +1,105 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsIRequest.idl" + +interface nsISimpleEnumerator; +interface nsIRequestObserver; +interface nsIInterfaceRequestor; +interface nsIRequestContext; + +/** + * A load group maintains a collection of nsIRequest objects. + * This is used in lots of places where groups of requests need to be tracked. + * For example, Document::mDocumentLoadGroup is used to track all requests + * made for subdocuments in order to track page load progress and allow all + * requests made on behalf of the document to be stopped, etc. + */ +[builtinclass, scriptable, uuid(f0c87725-7a35-463c-9ceb-2c07f23406cc)] +interface nsILoadGroup : nsIRequest +{ + /** + * The group observer is notified when requests are added to and removed + * from this load group. The groupObserver is weak referenced. + */ + attribute nsIRequestObserver groupObserver; + + /** + * Accesses the default load request for the group. Each time a number + * of requests are added to a group, the defaultLoadRequest may be set + * to indicate that all of the requests are related to a base request. + * + * The load group inherits its load flags from the default load request. + * If the default load request is NULL, then the group's load flags are + * not changed. + */ + attribute nsIRequest defaultLoadRequest; + + /** + * Adds a new request to the group. This will cause the default load + * flags to be applied to the request. If this is a foreground + * request then the groupObserver's onStartRequest will be called. + * + * If the request is the default load request or if the default load + * request is null, then the load group will inherit its load flags from + * the request. + */ + void addRequest(in nsIRequest aRequest, + in nsISupports aContext); + + /** + * Removes a request from the group. If this is a foreground request + * then the groupObserver's onStopRequest will be called. + * + * By the time this call ends, aRequest will have been removed from the + * loadgroup, even if this function throws an exception. + */ + void removeRequest(in nsIRequest aRequest, + in nsISupports aContext, + in nsresult aStatus); + + /** + * Returns the requests contained directly in this group. + * Enumerator element type: nsIRequest. + */ + readonly attribute nsISimpleEnumerator requests; + + /** + * Returns the count of "active" requests (ie. requests without the + * LOAD_BACKGROUND bit set). + */ + readonly attribute unsigned long activeCount; + + /** + * Notification callbacks for the load group. + */ + attribute nsIInterfaceRequestor notificationCallbacks; + + /** + * Context for managing things like js/css connection blocking, + * and per-tab connection grouping. + */ + readonly attribute unsigned long long requestContextID; + + /** + * The set of load flags that will be added to all new requests added to + * this group. Any existing requests in the load group are not modified, + * so it is expected these flags will be added before requests are added + * to the group - typically via nsIDocShell::defaultLoadFlags on a new + * docShell. + * Note that these flags are *not* added to the default request for the + * load group; it is expected the default request will already have these + * flags (again, courtesy of setting nsIDocShell::defaultLoadFlags before + * the docShell has created the default request.) + */ + attribute nsLoadFlags defaultLoadFlags; + + /** + * Returns true if the loadGroup belongs to a discarded context, such as, a + * terminated private browsing session. + */ + [infallible] + readonly attribute boolean isBrowsingContextDiscarded; +}; diff --git a/netwerk/base/nsILoadGroupChild.idl b/netwerk/base/nsILoadGroupChild.idl new file mode 100644 index 0000000000..e31fbcc6f0 --- /dev/null +++ b/netwerk/base/nsILoadGroupChild.idl @@ -0,0 +1,42 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +interface nsILoadGroup; + +/** + * nsILoadGroupChild provides a hierarchy of load groups so that the + * root load group can be used to conceptually tie a series of loading + * operations into a logical whole while still leaving them separate + * for the purposes of cancellation and status events. + */ + +[builtinclass, scriptable, uuid(02efe8e2-fbbc-4718-a299-b8a09c60bf6b)] +interface nsILoadGroupChild : nsISupports +{ + /** + * The parent of this load group. It is stored with + * a nsIWeakReference/nsWeakPtr so there is no requirement for the + * parentLoadGroup to out live the child, nor will the child keep a + * reference count on the parent. + */ + attribute nsILoadGroup parentLoadGroup; + + /** + * The nsILoadGroup associated with this nsILoadGroupChild + */ + readonly attribute nsILoadGroup childLoadGroup; + + /** + * The rootLoadGroup is the recursive parent of this + * load group where parent is defined as parentlLoadGroup if set + * or childLoadGroup.loadGroup as a backup. (i.e. parentLoadGroup takes + * precedence.) The nsILoadGroup child is the root if neither parent + * nor loadgroup attribute is specified. + */ + readonly attribute nsILoadGroup rootLoadGroup; +}; + diff --git a/netwerk/base/nsILoadInfo.idl b/netwerk/base/nsILoadInfo.idl new file mode 100644 index 0000000000..f975d5a3c8 --- /dev/null +++ b/netwerk/base/nsILoadInfo.idl @@ -0,0 +1,1351 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: ft=cpp tw=78 sw=2 et ts=2 sts=2 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/. */ + +#include "nsISupports.idl" +#include "nsIContentPolicy.idl" +#include "nsIScriptSecurityManager.idl" + +interface nsIChannel; +interface nsIContentSecurityPolicy; +interface nsICookieJarSettings; +interface nsICSPEventListener; +interface nsINode; +interface nsIPrincipal; +interface nsIRedirectHistoryEntry; +interface nsIURI; +webidl Document; +webidl BrowsingContext; +native LoadContextRef(already_AddRefed<nsISupports>); +%{C++ +#include "nsTArray.h" +#include "mozilla/LoadTainting.h" +#include "mozilla/OriginAttributes.h" +#include "mozilla/UniquePtr.h" +#include "nsStringFwd.h" + +namespace mozilla { +namespace dom { +class ClientInfo; +class ClientSource; +class PerformanceStorage; +class ServiceWorkerDescriptor; +} // namespace dom +} // namespace mozilla +%} + +[ref] native nsIRedirectHistoryEntryArray(const nsTArray<nsCOMPtr<nsIRedirectHistoryEntry>>); +native OriginAttributes(mozilla::OriginAttributes); +[ref] native const_OriginAttributesRef(const mozilla::OriginAttributes); +[ref] native CStringArrayRef(const nsTArray<nsCString>); +[ref] native StringArrayRef(const nsTArray<nsString>); +[ref] native Uint64ArrayRef(const nsTArray<uint64_t>); +[ref] native PrincipalArrayRef(const nsTArray<nsCOMPtr<nsIPrincipal>>); +[ref] native const_ClientInfoRef(const mozilla::dom::ClientInfo); + native UniqueClientSource(mozilla::UniquePtr<mozilla::dom::ClientSource>); + native UniqueClientSourceMove(mozilla::UniquePtr<mozilla::dom::ClientSource>&&); +[ref] native const_MaybeClientInfoRef(const mozilla::Maybe<mozilla::dom::ClientInfo>); +[ref] native const_ServiceWorkerDescriptorRef(const mozilla::dom::ServiceWorkerDescriptor); +[ref] native const_MaybeServiceWorkerDescriptorRef(const mozilla::Maybe<mozilla::dom::ServiceWorkerDescriptor>); +[ptr] native PerformanceStoragePtr(mozilla::dom::PerformanceStorage); + native LoadTainting(mozilla::LoadTainting); + native CSPRef(already_AddRefed<nsIContentSecurityPolicy>); + +typedef unsigned long nsSecurityFlags; + +/** + * The LoadInfo object contains information about a network load, why it + * was started, and how we plan on using the resulting response. + * If a network request is redirected, the new channel will receive a new + * LoadInfo object. The new object will contain mostly the same + * information as the pre-redirect one, but updated as appropriate. + * For detailed information about what parts of LoadInfo are updated on + * redirect, see documentation on individual properties. + */ +[scriptable, builtinclass, uuid(ddc65bf9-2f60-41ab-b22a-4f1ae9efcd36)] +interface nsILoadInfo : nsISupports +{ + /** + * The following five flags determine the security mode and hence what kind of + * security checks should be performed throughout the lifetime of the channel. + * + * * SEC_REQUIRE_SAME_ORIGIN_INHERITS_SEC_CONTEXT + * * SEC_REQUIRE_SAME_ORIGIN_DATA_IS_BLOCKED + * * SEC_ALLOW_CROSS_ORIGIN_INHERITS_SEC_CONTEXT + * * SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL + * * SEC_REQUIRE_CORS_INHERITS_SEC_CONTEXT + * + * Exactly one of these flags are required to be set in order to allow + * the channel to perform the correct security checks (SOP, CORS, ...) and + * return the correct result principal. If none or more than one of these + * flags are set AsyncOpen will fail. + */ + + /** + * Warning: Never use this flag when creating a new channel! + * Only use this flag if you have to create a temporary LoadInfo + * for performing an explicit nsIContentPolicy check, like e.g. + * when loading something from the cache that needs an explicit + * nsIContentPolicy check. In all other cases pick one of the + * security flags underneath. + */ + const unsigned long SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK = 0; + + /* + * Enforce the same origin policy where loads inherit the principal. + * See the documentation for principalToInherit, which describes exactly what + * principal is inherited. + */ + const unsigned long SEC_REQUIRE_SAME_ORIGIN_INHERITS_SEC_CONTEXT = (1<<0); + + /* + * Enforce the same origin policy and data: loads are blocked. + */ + const unsigned long SEC_REQUIRE_SAME_ORIGIN_DATA_IS_BLOCKED = (1<<1); + + /** + * Allow loads from other origins. Loads which inherit the principal should + * see the documentation for principalToInherit, which describes exactly what + * principal is inherited. + * + * Commonly used by plain <img>, <video>, <link rel=stylesheet> etc. + */ + const unsigned long SEC_ALLOW_CROSS_ORIGIN_INHERITS_SEC_CONTEXT = (1 << 2); + + /** + * Allow loads from other origins. Loads from data: will be allowed, + * but the resulting resource will get a null principal. + * Used in blink/webkit for <iframe>s. Likely also the mode + * that should be used by most Chrome code. + */ + const unsigned long SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL = (1<<3); + + /** + * Allow loads from any origin, but require CORS for cross-origin loads. + * See the documentation for principalToInherit, which describes exactly what + * principal is inherited. + * + * Commonly used by <img crossorigin>, <video crossorigin>, + * XHR, fetch(), etc. + */ + const unsigned long SEC_REQUIRE_CORS_INHERITS_SEC_CONTEXT = (1<<4); + + /** + * Choose cookie policy. The default policy is equivalent to "INCLUDE" for + * SEC_REQUIRE_SAME_ORIGIN_* and SEC_ALLOW_CROSS_ORIGIN_* modes, and + * equivalent to "SAME_ORIGIN" for SEC_REQUIRE_CORS_INHERITS_SEC_CONTEXT mode. + * + * This means that if you want to perform a CORS load with credentials, pass + * SEC_COOKIES_INCLUDE. + * + * Note that these flags are still subject to the user's cookie policies. + * For example, if the user is blocking 3rd party cookies, those cookies + * will be blocked no matter which of these flags are set. + */ + const unsigned long SEC_COOKIES_DEFAULT = (0 << 5); + const unsigned long SEC_COOKIES_INCLUDE = (1 << 5); + const unsigned long SEC_COOKIES_SAME_ORIGIN = (2 << 5); + const unsigned long SEC_COOKIES_OMIT = (3 << 5); + + /** + * Force inheriting of the principal. See the documentation for + * principalToInherit, which describes exactly what principal is inherited. + * + * Setting this flag will cause GetChannelResultPrincipal to return the + * principal to be inherited as the channel principal. + * + * This will happen independently of the scheme of the URI that the + * channel is loading. + * + * So if the principal that gets inherited is "http://a.com/", and the channel + * is loading the URI "http://b.com/whatever", GetChannelResultPrincipal + * will return a principal from "http://a.com/". + * + * This flag can not be used together with SANDBOXED_ORIGIN sandbox flag. If + * both are passed to the LoadInfo constructor then this flag will be dropped. + * If you need to know whether this flag would have been present but was dropped + * due to sandboxing, check for the forceInheritPrincipalDropped flag. + */ + const unsigned long SEC_FORCE_INHERIT_PRINCIPAL = (1<<7); + + /** + * Inherit the Principal for about:blank. + */ + const unsigned long SEC_ABOUT_BLANK_INHERITS = (1<<9); + + /** + * Allow access to chrome: packages that are content accessible. + */ + const unsigned long SEC_ALLOW_CHROME = (1<<10); + + /** + * Disallow access to javascript: uris. + */ + const unsigned long SEC_DISALLOW_SCRIPT = (1<<11); + + /** + * Don't follow redirects. Instead the redirect response is returned + * as a successful response for the channel. + * + * Redirects not initiated by a server response, i.e. REDIRECT_INTERNAL and + * REDIRECT_STS_UPGRADE, are still followed. + * + * Note: If this flag is set and the channel response is a redirect, then + * the response body might not be available. + * This can happen if the redirect was cached. + */ + const unsigned long SEC_DONT_FOLLOW_REDIRECTS = (1<<12); + + /** + * Load an error page, it should be one of following : about:neterror, + * about:certerror, about:blocked, about:tabcrashed or about:restartrequired. + */ + const unsigned long SEC_LOAD_ERROR_PAGE = (1<<13); + + /** + * Force inheriting of the principal, overruling any owner that might be set + * on the channel. (Please note that channel.owner is deprecated and will be + * removed within Bug 1286838). See the documentation for principalToInherit, + * which describes exactly what principal is inherited. + * + * Setting this flag will cause GetChannelResultPrincipal to return the + * principal to be inherited as the channel principal. + * + * This will happen independently of the scheme of the URI that the + * channel is loading. + */ + const unsigned long SEC_FORCE_INHERIT_PRINCIPAL_OVERRULE_OWNER = (1<<14); + + /** + * This is the principal of the network request's caller/requester where + * the resulting resource will be used. I.e. it is the principal which + * will get access to the result of the request. (Where "get access to" + * might simply mean "embed" depending on the type of resource that is + * loaded). + * + * For example for an image, it is the principal of the document where + * the image is rendered. For a stylesheet it is the principal of the + * document where the stylesheet will be applied. + * + * So if document at http://a.com/page.html loads an image from + * http://b.com/pic.jpg, then loadingPrincipal will be + * http://a.com/page.html. + * + * For <iframe> and <frame> loads, the LoadingPrincipal is the + * principal of the parent document. For top-level loads, the + * LoadingPrincipal is null. For all loads except top-level loads + * the LoadingPrincipal is never null. + * + * If the loadingPrincipal is the system principal, no security checks + * will be done at all. There will be no security checks on the initial + * load or any subsequent redirects. This means there will be no + * nsIContentPolicy checks or any CheckLoadURI checks. Because of + * this, never set the loadingPrincipal to the system principal when + * the URI to be loaded is controlled by a webpage. + * If the loadingPrincipal and triggeringPrincipal are both + * content principals, then we will always call into + * nsIContentPolicies and CheckLoadURI. The call to nsIContentPolicies + * and CheckLoadURI happen even if the URI to be loaded is same-origin + * with the loadingPrincipal or triggeringPrincipal. + */ + readonly attribute nsIPrincipal loadingPrincipal; + + /** + * A C++-friendly version of triggeringPrincipal. + * + * This is a bit awkward because we can't use + * binaryname(GetLoadingPrincipal). + */ + [noscript, notxpcom, nostdcall] + nsIPrincipal virtualGetLoadingPrincipal(); + +%{C++ + nsIPrincipal* GetLoadingPrincipal() { + return VirtualGetLoadingPrincipal(); + } +%} + + /** + * This is the principal which caused the network load to start. I.e. + * this is the principal which provided the URL to be loaded. This is + * often the same as the LoadingPrincipal, but there are a few cases + * where that's not true. + * + * For example for loads into an <iframe>, the LoadingPrincipal is always + * the principal of the parent document. However the triggeringPrincipal + * is the principal of the document which provided the URL that the + * <iframe> is navigating to. This could be the previous document inside + * the <iframe> which set document.location. Or a document elsewhere in + * the frame tree which contained a <a target="..."> which targetted the + * <iframe>. + * + * If a stylesheet links to a sub-resource, like an @imported stylesheet, + * or a background image, then the triggeringPrincipal is the principal + * of the stylesheet, while the LoadingPrincipal is the principal of the + * document being styled. + * + * The triggeringPrincipal is never null. + * + * If the triggeringPrincipal is the system principal, no security checks + * will be done at all. There will be no security checks on the initial + * load or any subsequent redirects. This means there will be no + * nsIContentPolicy checks or any CheckLoadURI checks. Because of + * this, never set the triggeringPrincipal to the system principal when + * the URI to be loaded is controlled by a webpage. + * If the loadingPrincipal and triggeringPrincipal are both + * content principals, then we will always call into + * nsIContentPolicies and CheckLoadURI. The call to nsIContentPolicies + * and CheckLoadURI happen even if the URI to be loaded is same-origin + * with the loadingPrincipal or triggeringPrincipal. + */ + readonly attribute nsIPrincipal triggeringPrincipal; + + /** + * A C++-friendly version of triggeringPrincipal. + */ + [noscript, notxpcom, nostdcall, binaryname(TriggeringPrincipal)] + nsIPrincipal binaryTriggeringPrincipal(); + + /** + * For non-document loads the principalToInherit is always null. For + * loads of type TYPE_DOCUMENT or TYPE_SUBDOCUMENT the principalToInherit + * might be null. If it's non null, then this is the principal that is + * inherited if a principal needs to be inherited. If the principalToInherit + * is null but the inherit flag is set, then the triggeringPrincipal is + * the principal that is inherited. + */ + attribute nsIPrincipal principalToInherit; + + /** + * A C++-friendly version of principalToInherit. + */ + [noscript, notxpcom, nostdcall, binaryname(PrincipalToInherit)] + nsIPrincipal binaryPrincipalToInherit(); + + /** + * Finds the correct principal to inherit for the given channel, based on + * the values of PrincipalToInherit and TriggeringPrincipal. + */ + [noscript, notxpcom, nostdcall] + nsIPrincipal FindPrincipalToInherit(in nsIChannel aChannel); + + /** + * This is the ownerDocument of the LoadingNode. Unless the LoadingNode + * is a Document, in which case the LoadingDocument is the same as the + * LoadingNode. + * + * For top-level loads, and for loads originating from workers, the + * LoadingDocument is null. When the LoadingDocument is not null, the + * LoadingPrincipal is set to the principal of the LoadingDocument. + */ + readonly attribute Document loadingDocument; + + /** + * A C++-friendly version of loadingDocument (loadingNode). + * This is the Node where the resulting resource will be used. I.e. it is + * the Node which will get access to the result of the request. (Where + * "get access to" might simply mean "embed" depending on the type of + * resource that is loaded). + * + * For example for an <img>/<video> it is the image/video element. For + * document loads inside <iframe> and <frame>s, the LoadingNode is the + * <iframe>/<frame> element. For an XMLHttpRequest, it is the Document + * which contained the JS which initiated the XHR. For a stylesheet, it + * is the Document that contains <link rel=stylesheet>. + * + * For loads triggered by the HTML pre-parser, the LoadingNode is the + * Document which is currently being parsed. + * + * For top-level loads, and for loads originating from workers, the + * LoadingNode is null. If the LoadingNode is non-null, then the + * LoadingPrincipal is the principal of the LoadingNode. + */ + [noscript, notxpcom, nostdcall, binaryname(LoadingNode)] + nsINode binaryLoadingNode(); + + /** + * A C++ friendly version of the loadingContext for toplevel loads. + * Most likely you want to query the ownerDocument or LoadingNode + * and not this context only available for TYPE_DOCUMENT loads. + * Please note that except for loads of TYPE_DOCUMENT, this + * ContextForTopLevelLoad will always return null. + */ + [noscript, notxpcom, nostdcall, binaryname(ContextForTopLevelLoad)] + LoadContextRef binaryContextForTopLevelLoad(); + + /** + * For all loads except loads of TYPE_DOCUMENT, the loadingContext + * simply returns the loadingNode. For loads of TYPE_DOCUMENT this + * will return the context available for top-level loads which + * do not have a loadingNode. + */ + [binaryname(LoadingContextXPCOM)] + readonly attribute nsISupports loadingContext; + + /** + * A C++ friendly version of the loadingContext. + */ + [noscript, notxpcom, nostdcall, binaryname(GetLoadingContext)] + LoadContextRef binaryGetLoadingContext(); + + /** + * The securityFlags of that channel. + */ + readonly attribute nsSecurityFlags securityFlags; + +%{C++ + inline nsSecurityFlags GetSecurityFlags() + { + nsSecurityFlags result; + mozilla::DebugOnly<nsresult> rv = GetSecurityFlags(&result); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + return result; + } +%} + + /** + * The sandboxFlags of that channel. + */ + [infallible] readonly attribute unsigned long sandboxFlags; + + /** + * The TriggingSandboxFlags are the SandboxFlags of the entity + * responsible for causing the load to occur. + */ + [infallible] attribute unsigned long triggeringSandboxFlags; + + /** + * Allows to query only the security mode bits from above. + */ + [infallible] readonly attribute unsigned long securityMode; + + /** + * This flag is used for any browsing context where we should not sniff + * the content type. E.g if an iframe has the XCTO nosniff header, then + * that flag is set to true so we skip content sniffing for that browsing + * context. + */ + [infallible] attribute boolean skipContentSniffing; + + /** + * (default) If this flag is set, it has not yet been determined if the + * HTTPS-Only mode will upgrade the request. + */ + const unsigned long HTTPS_ONLY_UNINITIALIZED = (1 << 0); + + /** + * Indicates that the request will get upgraded, and the HTTPS-Only + * StreamListener got registered. + */ + const unsigned long HTTPS_ONLY_UPGRADED_LISTENER_NOT_REGISTERED = (1 << 1); + + /** + * Indicates that this is the first time the request gets upgraded, and thus + * the HTTPS-Only StreamListener hasn't been registered yet. Even though there + * might be multiple channels per request that have to be upgraded (e.g., + * because of redirects), the StreamListener only has to be attached to one + * channel. + */ + const unsigned long HTTPS_ONLY_UPGRADED_LISTENER_REGISTERED = (1 << 2); + + /** + * This flag can be manually set if the HTTPS-Only mode should exempt the + * request and not upgrade it. (e.g in the case of OCSP. + */ + const unsigned long HTTPS_ONLY_EXEMPT = (1 << 3); + + /** + * This flag can only ever be set on top-level loads. It indicates + * that the top-level https connection succeeded. This flag is mostly + * used to counter time-outs which allows to cancel the channel + * if the https load has not started. + */ + const unsigned long HTTPS_ONLY_TOP_LEVEL_LOAD_IN_PROGRESS = (1 << 4); + + /** + * This flag indicates that the request should not be logged to the + * console. + */ + const unsigned long HTTPS_ONLY_DO_NOT_LOG_TO_CONSOLE = (1 << 5); + + /** + * Upgrade state of HTTPS-Only Mode. The flag HTTPS_ONLY_EXEMPT can get + * set on requests that should be excempt from an upgrade. + */ + [infallible] attribute unsigned long httpsOnlyStatus; + + /** + * Returns true if at the time of the loadinfo construction the document + * that triggered this load has the bit hasValidTransientUserGestureActivation + * set or the load was triggered from External. (Mostly this bool is used + * in the context of Sec-Fetch-User.) + */ + [infallible] attribute boolean hasValidUserGestureActivation; + + /** + * We disallow the SystemPrincipal to initiate requests to + * the public web. This flag is to allow exceptions. + */ + [infallible] attribute boolean allowDeprecatedSystemRequests; + + /** + * Only ever returns true if the loadinfo is of TYPE_SCRIPT and + * the script was created by the HTML parser. + */ + [infallible] attribute boolean parserCreatedScript; + + /** + * True if this request is from DevTools. + */ + [infallible] attribute boolean isInDevToolsContext; + + /** + * True if this request is embedded in a context that can't be third-party + * (i.e. an iframe embedded in a cross-origin parent window). If this is + * false, then this request may be third-party if it's a third-party to + * loadingPrincipal. + */ + [infallible] attribute boolean isInThirdPartyContext; + + /** + * True if this request is a third party in respect to the top-level window. + * + * Note that this doesn't consider the parent window. I.e. It will still + * return false even in the case that the parent is cross-origin but the + * top-level is same-origin. + * + * This value would be set during opening the channel in parent and propagate + * to the channel in the content. + */ + [infallible] attribute boolean isThirdPartyContextToTopWindow; + + /** + * See the SEC_COOKIES_* flags above. This attribute will never return + * SEC_COOKIES_DEFAULT, but will instead return what the policy resolves to. + * I.e. SEC_COOKIES_SAME_ORIGIN for CORS mode, and SEC_COOKIES_INCLUDE + * otherwise. + */ + [infallible] readonly attribute unsigned long cookiePolicy; + + /** + * The cookie jar settings inherited from the top-level document's loadInfo. + * It cannot be null. + */ + attribute nsICookieJarSettings cookieJarSettings; + + /** + * True if the loading document has the storage permission. This value would + * be set during opening the channel. + */ + [infallible] attribute boolean hasStoragePermission; + + /** + * If forceInheritPrincipal is true, the data coming from the channel should + * inherit its principal, even when the data is loaded over http:// or another + * protocol that would normally use a URI-based principal. + * + * See the documentation for principalToInherit, which describes exactly what + * principal is inherited. + * + * This attribute will never be true when loadingSandboxed is true. + */ + [infallible] readonly attribute boolean forceInheritPrincipal; + + /** + * If forceInheritPrincipalOverruleOwner is true, the data coming from the + * channel should inherit the principal, even when the data is loaded over + * http:// or another protocol that would normally use a URI-based principal + * and even if the channel's .owner is not null. This last is the difference + * between forceInheritPrincipalOverruleOwner and forceInheritPrincipal: the + * latter does _not_ overrule the .owner setting. + * + * See the documentation for principalToInherit, which describes exactly what + * principal is inherited. + */ + [infallible] readonly attribute boolean forceInheritPrincipalOverruleOwner; + + /** + * If loadingSandboxed is true, the data coming from the channel is + * being loaded sandboxed, so it should have a nonce origin and + * hence should use a NullPrincipal. + */ + [infallible] readonly attribute boolean loadingSandboxed; + + /** + * If aboutBlankInherits is true, then about:blank should inherit + * the principal. + */ + [infallible] readonly attribute boolean aboutBlankInherits; + + /** + * If allowChrome is true, then use nsIScriptSecurityManager::ALLOW_CHROME + * when calling CheckLoadURIWithPrincipal(). + */ + [infallible] readonly attribute boolean allowChrome; + + /** + * If disallowScript is true, then use nsIScriptSecurityManager::DISALLOW_SCRIPT + * when calling CheckLoadURIWithPrincipal(). + */ + [infallible] readonly attribute boolean disallowScript; + +%{C++ + uint32_t CheckLoadURIFlags() { + uint32_t flags = nsIScriptSecurityManager::STANDARD; + if (GetAllowChrome()) { + flags |= nsIScriptSecurityManager::ALLOW_CHROME; + } + if (GetDisallowScript()) { + flags |= nsIScriptSecurityManager::DISALLOW_SCRIPT; + } + return flags; + } +%} + + /** + * Returns true if SEC_DONT_FOLLOW_REDIRECTS is set. + */ + [infallible] readonly attribute boolean dontFollowRedirects; + + /** + * Returns true if SEC_LOAD_ERROR_PAGE is set. + */ + [infallible] readonly attribute boolean loadErrorPage; + + /** + * True if the load was initiated by a form request. + * This is important to know to handle the CSP directive navigate-to. + */ + [infallible] attribute boolean isFormSubmission; + + /** + * The external contentPolicyType of the channel, used for security checks + * like Mixed Content Blocking and Content Security Policy. + * + * Specifically, content policy types with _INTERNAL_ in their name will + * never get returned from this attribute. + */ + readonly attribute nsContentPolicyType externalContentPolicyType; + + /** + * CSP uses this parameter to send or not CSP violation events. + * Default value: true. + */ + [infallible] attribute boolean sendCSPViolationEvents; + +%{ C++ + inline ExtContentPolicyType GetExternalContentPolicyType() + { + nsContentPolicyType result; + mozilla::DebugOnly<nsresult> rv = GetExternalContentPolicyType(&result); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + return static_cast<ExtContentPolicyType>(result); + } +%} + + /** + * The internal contentPolicyType of the channel, used for constructing + * RequestContext values when creating a fetch event for an intercepted + * channel. + * + * This should not be used for the purposes of security checks, since + * the content policy implementations cannot be expected to deal with + * _INTERNAL_ values. Please use the contentPolicyType attribute above + * for that purpose. + */ + [noscript, notxpcom, nostdcall, binaryname(InternalContentPolicyType)] + nsContentPolicyType binaryInternalContentPolicyType(); + + readonly attribute nsContentPolicyType internalContentPolicyType; + + /** + * Returns true if document or any of the documents ancestors + * up to the toplevel document make use of the CSP directive + * 'block-all-mixed-content'. + * + * Warning: If the loadingDocument is null, then the + * blockAllMixedContent is false. + */ + [infallible] readonly attribute boolean blockAllMixedContent; + + /** + * Returns true if document or any of the documents ancestors + * up to the toplevel document make use of the CSP directive + * 'upgrade-insecure-requests'. + * + * Warning: If the loadingDocument is null, then the + * upgradeInsecureRequests is false. + */ + [infallible] readonly attribute boolean upgradeInsecureRequests; + + /** + * Returns true if the the page is https and the content is upgradable from http + * requires 'security.mixed_content.upgrade_display_content' pref to be true. + * Currently this only upgrades display content but might be expanded to other loads. + * This is very similar in implementation to upgradeInsecureRequests but browser set. + */ + [infallible] readonly attribute boolean browserUpgradeInsecureRequests; + + /** + * Returns true if the display content was or will get upgraded from http to https. + * Requires 'security.mixed_content.upgrade_display_content' pref to be true. + * Flag is set purely to collect telemetry. + */ + [infallible] attribute boolean browserDidUpgradeInsecureRequests; + + /** + * Returns true if the the page is https and the content is upgradable from http + * requires 'security.mixed_content.upgrade_display_content' pref to be false. + * See browserUpgradeInsecureRequests for more details, this only happens + * when *not* upgrading purely for telemetry. + */ + [infallible] readonly attribute boolean browserWouldUpgradeInsecureRequests; + + /** + * If true, toplevel data: URI navigation is allowed + */ + [infallible] attribute boolean forceAllowDataURI; + + /** + * If true, insecure redirects to a data: URI are allowed. + */ + [infallible] attribute boolean allowInsecureRedirectToDataURI; + + /** + * If true, CORS checks will be skipped. + */ + [infallible] attribute boolean bypassCORSChecks; + + /** + * If true, the content policy security check is excluded from web requests. + */ + [infallible] attribute boolean skipContentPolicyCheckForWebRequest; + + /** + * If true, this is the load of a frame's original src attribute + */ + [infallible] attribute boolean originalFrameSrcLoad; + + /** + * The SEC_FORCE_INHERIT_PRINCIPAL flag may be dropped when a load info + * object is created. Specifically, it will be dropped if the SANDBOXED_ORIGIN + * sandbox flag is also present. This flag is set if SEC_FORCE_INHERIT_PRINCIPAL + * was dropped. + */ + [infallible] readonly attribute boolean forceInheritPrincipalDropped; + + /** + * This is the inner window ID of the window in which the element being + * loaded lives. + * + * Note that this window ID can be 0 if the window is not + * available. + */ + [infallible] readonly attribute unsigned long long innerWindowID; + + /** + * The BrowsingContext performing the load for this nsILoadInfo object. + */ + [infallible] readonly attribute unsigned long long browsingContextID; + [infallible] readonly attribute BrowsingContext browsingContext; + + /** + * Only when the element being loaded is <frame src="foo.html"> + * (or, more generally, if the element QIs to nsFrameLoaderOwner), + * the frameBrowsingContext is the browsing context containing the + * foo.html document. + * + * Note: For other cases, frameBrowsingContextID is 0. + */ + [infallible] readonly attribute unsigned long long frameBrowsingContextID; + [infallible] readonly attribute BrowsingContext frameBrowsingContext; + + /** + * If the element being loaded is a nsFrameLoaderOwner, + * `targetBrowsingContext` is the Browsing Context which will contain the + * loading document (see `frameBrowsingContext`). Otherwise, it is the + * Browsing Context performing the load (see `browsingContext`). + */ + [infallible] readonly attribute unsigned long long targetBrowsingContextID; + [infallible] readonly attribute BrowsingContext targetBrowsingContext; + + /** + * Resets the PrincipalToInherit to a freshly created NullPrincipal + * which inherits the origin attributes from the loadInfo. + * + * WARNING: Please only use that function if you know exactly what + * you are doing!!! + */ + void resetPrincipalToInheritToNullPrincipal(); + + /** + * Customized OriginAttributes within LoadInfo to allow overwriting of the + * default originAttributes from the loadingPrincipal. + * + * In chrome side, originAttributes.privateBrowsingId will always be 0 even if + * the usePrivateBrowsing is true, because chrome docshell won't set + * privateBrowsingId on origin attributes (See bug 1278664). This is to make + * sure nsILoadInfo and nsILoadContext have the same origin attributes. + */ + [implicit_jscontext, binaryname(ScriptableOriginAttributes)] + attribute jsval originAttributes; + + [noscript, nostdcall, binaryname(GetOriginAttributes)] + OriginAttributes binaryGetOriginAttributes(); + + [noscript, nostdcall, binaryname(SetOriginAttributes)] + void binarySetOriginAttributes(in const_OriginAttributesRef aOriginAttrs); + +%{ C++ + inline mozilla::OriginAttributes GetOriginAttributes() + { + mozilla::OriginAttributes result; + mozilla::DebugOnly<nsresult> rv = GetOriginAttributes(&result); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + return result; + } +%} + + /** + * Whenever a channel is evaluated by the ContentSecurityManager + * the first time, we set this flag to true to indicate that + * subsequent calls of AsyncOpen() do not have to enforce all + * security checks again. E.g., after a redirect there is no + * need to set up CORS again. We need this separate flag + * because the redirectChain might also contain internal + * redirects which might pollute the redirectChain so we can't + * rely on the size of the redirectChain-array to query whether + * a channel got redirected or not. + * + * Please note, once the flag is set to true it must remain true + * throughout the lifetime of the channel. Trying to set it + * to anything else than true will be discarded. + * + */ + [infallible] attribute boolean initialSecurityCheckDone; + + /** + * Returns true if the load was triggered from an external application + * (e.g. Thunderbird). Please note that this flag will only ever be true + * if the load is of TYPE_DOCUMENT. + */ + [infallible] attribute boolean loadTriggeredFromExternal; + + /** + * True if the tainting has been set by the service worker. + */ + [noscript, infallible] readonly attribute boolean serviceWorkerTaintingSynthesized; + + /** + * Whenever a channel gets redirected, append the redirect history entry of + * the channel which contains principal referrer and remote address [before + * the channels got redirected] to the loadinfo, so that at every point this + * array provides us information about all the redirects this channel went + * through. + * @param entry, the nsIRedirectHistoryEntry before the channel + * got redirected. + * @param aIsInternalRedirect should be true if the channel is going + * through an internal redirect, otherwise false. + */ + void appendRedirectHistoryEntry(in nsIRedirectHistoryEntry entry, + in boolean isInternalRedirect); + + /** + * An array of nsIRedirectHistoryEntry which stores redirects associated + * with this channel. This array is filled whether or not the channel has + * ever been opened. The last element of the array is associated with the + * most recent redirect. Please note, that this array *includes* internal + * redirects. + */ + [implicit_jscontext] + readonly attribute jsval redirectChainIncludingInternalRedirects; + + /** + * A C++-friendly version of redirectChain. + * Please note that this array has the same lifetime as the + * loadInfo object - use with caution! + */ + [noscript, notxpcom, nostdcall, binaryname(RedirectChainIncludingInternalRedirects)] + nsIRedirectHistoryEntryArray binaryRedirectChainIncludingInternalRedirects(); + + /** + * Same as RedirectChain but does *not* include internal redirects. + */ + [implicit_jscontext] + readonly attribute jsval redirectChain; + + /** + * A C++-friendly version of redirectChain. + * Please note that this array has the same lifetime as the + * loadInfo object - use with caution! + */ + [noscript, notxpcom, nostdcall, binaryname(RedirectChain)] + nsIRedirectHistoryEntryArray binaryRedirectChain(); + + /** + * This array is only filled out when we are in the parent process and we are + * creating a loadInfo object or deserializing LoadInfoArgs into LoadInfo, + * as we ever only need in the parent process. + * + * The array is meant to be a list of principals of the documents that the + * browsing context, corresponding to this loadInfo object, is "nested through" in + * the sense of + * <https://html.spec.whatwg.org/multipage/browsers.html#browsing-context-nested-through>. + * Note that the array does not include the principal corresponding to the frame + * loading this request. The closest ancestor is at index zero and the top level + * ancestor is at the last index. + * + * If this is a toplevel content browsing context (i.e. toplevel document in spec + * terms), the list is empty. + * + * Otherwise the array is a list for the document we're nested through (again in + * the spec sense), with the principal of that document prepended. The + * ancestorPrincipals[0] entry for an iframe load will be the principal of the + * iframe element's owner document. The ancestorPrincipals[0] entry for an image + * loaded in an iframe will be the principal of the iframe element's owner + * document. This matches the ordering specified for Location.ancestorOrigins. + * + * Please note that this array has the same lifetime as the loadInfo object - use + * with caution! + */ + [noscript, notxpcom, nostdcall] + PrincipalArrayRef AncestorPrincipals(); + + /** + * An array of BrowsingContext IDs which correspond to nsILoadInfo::AncestorPrincipals + * above. AncestorBrowsingContextIDs[0] is the BrowsingContext ID of the frame + * associated with the principal at ancestorPrincipals[0], and so forth. + * + * Please note that this array has the same lifetime as the + * loadInfo object - use with caution! + */ + [noscript, notxpcom, nostdcall] + Uint64ArrayRef AncestorBrowsingContextIDs(); + + /** + * Sets the list of unsafe headers according to CORS spec, as well as + * potentially forces a preflight. + * Note that you do not need to set the Content-Type header. That will be + * automatically detected as needed. + * + * Only call this function when using the SEC_REQUIRE_CORS_INHERITS_SEC_CONTEXT mode. + */ + [noscript, notxpcom, nostdcall] + void setCorsPreflightInfo(in CStringArrayRef unsafeHeaders, + in boolean forcePreflight); + + /** + * A C++-friendly getter for the list of cors-unsafe headers. + * Please note that this array has the same lifetime as the + * loadInfo object - use with caution! + */ + [noscript, notxpcom, nostdcall, binaryname(CorsUnsafeHeaders)] + CStringArrayRef corsUnsafeHeaders(); + + /** + * Returns value set through setCorsPreflightInfo. + */ + [infallible] readonly attribute boolean forcePreflight; + + /** + * A C++ friendly getter for the forcePreflight flag. + */ + [infallible] readonly attribute boolean isPreflight; + + /** + * Constants reflecting the channel tainting. These are mainly defined here + * for script. Internal C++ code should use the enum defined in LoadTainting.h. + * See LoadTainting.h for documentation. + */ + const unsigned long TAINTING_BASIC = 0; + const unsigned long TAINTING_CORS = 1; + const unsigned long TAINTING_OPAQUE = 2; + + /** + * Determine the associated channel's current tainting. Note, this can + * change due to a service worker intercept, so it should be checked after + * OnStartRequest() fires. + */ + readonly attribute unsigned long tainting; + + /** + * Note a new tainting level and possibly increase the current tainting + * to match. If the tainting level is already greater than the given + * value, then there is no effect. It is not possible to reduce the tainting + * level on an existing channel/loadinfo. + */ + void maybeIncreaseTainting(in unsigned long aTainting); + + /** + * Various helper code to provide more convenient C++ access to the tainting + * attribute and maybeIncreaseTainting(). + */ +%{C++ + static_assert(TAINTING_BASIC == static_cast<uint32_t>(mozilla::LoadTainting::Basic), + "basic tainting enums should match"); + static_assert(TAINTING_CORS == static_cast<uint32_t>(mozilla::LoadTainting::CORS), + "cors tainting enums should match"); + static_assert(TAINTING_OPAQUE == static_cast<uint32_t>(mozilla::LoadTainting::Opaque), + "opaque tainting enums should match"); + + mozilla::LoadTainting GetTainting() + { + uint32_t tainting = TAINTING_BASIC; + MOZ_ALWAYS_SUCCEEDS(GetTainting(&tainting)); + return static_cast<mozilla::LoadTainting>(tainting); + } + + void MaybeIncreaseTainting(mozilla::LoadTainting aTainting) + { + uint32_t tainting = static_cast<uint32_t>(aTainting); + MOZ_ALWAYS_SUCCEEDS(MaybeIncreaseTainting(tainting)); + } +%} + + /** + * Returns true if this load is for top level document. + * Note that the load for a sub-frame's document will return false here. + */ + [infallible] readonly attribute boolean isTopLevelLoad; + + /** + * If this is non-null, this property represents two things: (1) the + * URI to be used for the principal if the channel with this loadinfo + * gets a principal based on URI and (2) the URI to use for a document + * created from the channel with this loadinfo. + */ + attribute nsIURI resultPrincipalURI; + + /** + * Returns the null principal of the resulting resource if the SANDBOXED_ORIGIN + * flag is set. Otherwise returns null. This is used by + * GetChannelResultPrincipal() to ensure that the same null principal object + * is returned every time. + */ + [notxpcom, nostdcall] readonly attribute nsIPrincipal sandboxedLoadingPrincipal; + + /** + * Return the top-level principal, which is the principal of the top-level + * window. + */ + [notxpcom, nostdcall] readonly attribute nsIPrincipal topLevelPrincipal; + + /** + * Return the top-level storage area principal, which is the principal of + * the top-level window if it's not a 3rd party context, non tracking + * resource. + */ + [notxpcom, nostdcall] readonly attribute nsIPrincipal topLevelStorageAreaPrincipal; + + /** + * Note which client (i.e. global) initiated this network request. All + * nsGlobalWindow and WorkerPrivate can be converted to a ClientInfo to + * be set here. While this is being added to support service worker + * FetchEvent, it can also be used to communicate other information about + * the source global context in the future. + */ + [noscript, nostdcall, notxpcom] + void SetClientInfo(in const_ClientInfoRef aClientInfo); + + /** + * Get the ClientInfo for the global that initiated the network request, + * if it has been set. + */ + [noscript, nostdcall, notxpcom] + const_MaybeClientInfoRef GetClientInfo(); + + /** + * Give a pre-allocated ClientSource to the channel LoadInfo. This is + * intended to be used by docshell when loading windows without an + * initial about:blank document. The docshell will allocate the ClientSource + * to represent the client that will be created as a result of the navigation + * network request. If the channel succeeds and remains same-origin, then + * the result nsGlobalWindow will take ownership of the reserved ClientSource. + * + * This method is also called when a cross-origin redirect occurs. A new + * ClientSource with a different UUID must be created in this case. + * + * This method automatically calls SetReservedClientInfo() with the + * ClientSource::Info(). + */ + [noscript, nostdcall, notxpcom] + void GiveReservedClientSource(in UniqueClientSourceMove aClientSource); + + /** + * This method takes ownership of the reserved ClientSource previously + * provided in GiveReservedClientSource(). It may return nullptr if the + * nsILoadInfo does not own a ClientSource object. + */ + [noscript, nostdcall, notxpcom] + UniqueClientSource TakeReservedClientSource(); + + /** + * Note the reserved client that be created if this non-subresource + * network request succeeds. Depending on the type of client this + * may be called directly or indirectly via GiveReservedClientSource(). + * For example, web workers do not call give their ClientSource to + * the nsILoadInfo, but must still call this method to indicate the + * reserved client for their main script load. + */ + [noscript, nostdcall, notxpcom] + void SetReservedClientInfo(in const_ClientInfoRef aClientInfo); + + /** + * This will clear any existing reserved or initial client and override + * it with the given reserved client. This is similar to calling + * TakeReservedClientSource() and then GiveReservedClientSource() with + * a new client as ClientChannelHelper does. This method is needed, + * though, to perform this operation in the parent process where + * the LoadInfo does not have direct access to a ClientSource. + * + * If in doubt, do not call this method. Its really only needed for + * a specific redirect case where the child has created a new client on + * redirect and we need to override the parent side's reserved client + * to match. + */ + [noscript, nostdcall, notxpcom] + void OverrideReservedClientInfoInParent(in const_ClientInfoRef aClientInfo); + + /** + * Return the reserved ClientInfo for this load, if one has been set. + */ + [noscript, nostdcall, notxpcom] + const_MaybeClientInfoRef GetReservedClientInfo(); + + /** + * Note that this non-subresource network request will result in + * re-using an existing "initial" active client. This mainly only + * happens when an initial about:blank document is replaced with + * a real load in a window. In these cases we need to track this + * initial client so that we may report its existence in a FetchEvent. + * + * Note, an nsILoadInfo may only have a reserved client or an + * initial client. It should never have both. + */ + [noscript, nostdcall, notxpcom] + void SetInitialClientInfo(in const_ClientInfoRef aClientInfo); + + /** + * Return the initial ClientInfo for this load, if one has been set. + */ + [noscript, nostdcall, notxpcom] + const_MaybeClientInfoRef GetInitialClientInfo(); + + /** + * Note that this network request should be controlled by a service worker. + * For non-subresource requests this may be set during the load when + * the first service worker interception occurs. For subresource requests + * it may be set by the source client if its already controlled by a + * service worker. + */ + [noscript, nostdcall, notxpcom] + void SetController(in const_ServiceWorkerDescriptorRef aServiceWorker); + + /** + * Clear the service worker controller for this channel. This should only + * be used for window navigation redirects. By default we want to keep + * the controller in all other cases. + */ + [noscript, nostdcall, notxpcom] + void ClearController(); + + /** + * Get the service worker controlling this network request, if one has + * been set. + */ + [noscript, nostdcall, notxpcom] + const_MaybeServiceWorkerDescriptorRef GetController(); + + /** + * Set a custom performance storage. This is meant to be executed only for + * workers. If a PerformanceStorage is not set, the loadingDocument->Window + * Performance object will be returned instead. + */ + [noscript, nostdcall, notxpcom] + void SetPerformanceStorage(in PerformanceStoragePtr aPerformanceStorage); + + /** + * Get the custom PerformanceStorage if set by SetPerformanceStorage. + * Otherwise the loadingDocument->Window Performance object will be returned + * instead if all the following conditions are met: + * - the triggeringPrincipal is the same as the loadingDocument's principal. + * - if the external content policy type is TYPE_SUBDOCUMENT then loading + * wasn't caused by processing the attributes of the browsing context + * container. + */ + [noscript, nostdcall, notxpcom] + PerformanceStoragePtr GetPerformanceStorage(); + + /** + * Returns the CSP (or Preload CSP for preloads) which should be enforced + * when fetching the resource this loadinfo belongs to. + * + * a) Non-navigations: + * For non-navigation loads, GetCSP() returns what the spec refers to as the + * "request's client's global object's CSP list". In practice, if this is the + * loadinfo of a subresource load (e.g an image load), then GetCSP() or + * GetPreloadCSP() returns the CSP of the document which embeds the image. + * The returned CSP includes any policy delivered through the HTTP header or + * also through the meta tag (modulo the difference for preloads, e.g. image + * preloads have to query GetPreloadCsp() because at the time of preloading + * we are not entirely sure if the Meta CSP will be applied to the document + * in the end or not). Please note that GetCSPToInherit() called on a + * loadinfo for any non-navigation always returns null. + * + * b) Navigations: + * * Top-level loads: + * For top-level loads (navigations) GetCSP() will return null, unless + * the navigation is started by a WebExtension, in which case it will + * return the CSP of the webextension, if any. + * If you need to query the CSP that potentially should apply to the + * new top-level load, you have to query GetCspToInherit(), which is + * the CSP of the request's client's global object, just like GetCsp() + * is for non-navigation requests. + * + * * Iframe-loads: + * For iframe-loads (navigations) GetCSP() will return the CSP of the + * parent document, unless the navigation is started by a WebExtension, + * in which case it will return the CSP of the webextension, if any. + * + * If you need to query the CSP that should potentially be inherited + * into the new document, you have to query GetCSPToInherit(). + * + * TODO Bug 1557114: + * After evaluating what CSP to use for frame navigations we should + * update the above documentation to match the outcome of Bug 1557114. + */ + [notxpcom,nostdcall] CSPRef GetCsp(); + [notxpcom,nostdcall] CSPRef GetPreloadCsp(); + [notxpcom,nostdcall] CSPRef GetCspToInherit(); + + /** + * The service worker and fetch specifications require returning the + * exact tainting level of the Response passed to FetchEvent.respondWith(). + * This method allows us to override the tainting level in that case. + * + * NOTE: This should not be used outside of service worker code! Use + * nsILoadInfo::MaybeIncreaseTainting() instead. + */ + [noscript, nostdcall, notxpcom] + void SynthesizeServiceWorkerTainting(in LoadTainting aTainting); + + /** + * The top-level document has been user-interacted. + */ + [infallible] attribute boolean documentHasUserInteracted; + + /** + * During a top-level document channel redirect from tracking to + * non-tracking resources, our anti-tracking heuristic, grants the storage + * access permission for a short amount of seconds (See + * privacy.restrict3rdpartystorage.expiration_redirect pref). + * We use this flag to remember this decision even if this channel is part + * of a chain of redirects. + */ + [infallible] attribute boolean allowListFutureDocumentsCreatedFromThisRedirectChain; + + /** + * A snapshot of the nonce at load start time which is used for CSP + * checks and only set for: + * * TYPE_SCRIPT and + * * TYPE_STYLESHEET + */ + attribute AString cspNonce; + + /** + * List of possible reasons the request associated with this load info + * may have been blocked, set by various content blocking checkers. + */ + const uint32_t BLOCKING_REASON_NONE = 0; + const uint32_t BLOCKING_REASON_CORSDISABLED = 1001; + const uint32_t BLOCKING_REASON_CORSDIDNOTSUCCEED = 1002; + const uint32_t BLOCKING_REASON_CORSREQUESTNOTHTTP = 1003; + const uint32_t BLOCKING_REASON_CORSMULTIPLEALLOWORIGINNOTALLOWED = 1004; + const uint32_t BLOCKING_REASON_CORSMISSINGALLOWORIGIN = 1005; + const uint32_t BLOCKING_REASON_CORSNOTSUPPORTINGCREDENTIALS = 1006; + const uint32_t BLOCKING_REASON_CORSALLOWORIGINNOTMATCHINGORIGIN = 1007; + const uint32_t BLOCKING_REASON_CORSMISSINGALLOWCREDENTIALS = 1008; + const uint32_t BLOCKING_REASON_CORSORIGINHEADERNOTADDED = 1009; + const uint32_t BLOCKING_REASON_CORSEXTERNALREDIRECTNOTALLOWED = 1010; + const uint32_t BLOCKING_REASON_CORSPREFLIGHTDIDNOTSUCCEED = 1011; + const uint32_t BLOCKING_REASON_CORSINVALIDALLOWMETHOD = 1012; + const uint32_t BLOCKING_REASON_CORSMETHODNOTFOUND = 1013; + const uint32_t BLOCKING_REASON_CORSINVALIDALLOWHEADER = 1014; + const uint32_t BLOCKING_REASON_CORSMISSINGALLOWHEADERFROMPREFLIGHT = 1015; + const uint32_t BLOCKING_REASON_CLASSIFY_MALWARE_URI = 2001; + const uint32_t BLOCKING_REASON_CLASSIFY_PHISHING_URI = 2002; + const uint32_t BLOCKING_REASON_CLASSIFY_UNWANTED_URI = 2003; + const uint32_t BLOCKING_REASON_CLASSIFY_TRACKING_URI = 2004; + const uint32_t BLOCKING_REASON_CLASSIFY_BLOCKED_URI = 2005; + const uint32_t BLOCKING_REASON_CLASSIFY_HARMFUL_URI = 2006; + const uint32_t BLOCKING_REASON_CLASSIFY_CRYPTOMINING_URI = 2007; + const uint32_t BLOCKING_REASON_CLASSIFY_FINGERPRINTING_URI = 2008; + const uint32_t BLOCKING_REASON_CLASSIFY_SOCIALTRACKING_URI = 2009; + const uint32_t BLOCKING_REASON_MIXED_BLOCKED = 3001; + // The general reason comes from nsCSPContext::permitsInternal(), + // which is way too generic to distinguish an exact reason. + const uint32_t BLOCKING_REASON_CONTENT_POLICY_GENERAL = 4000; + const uint32_t BLOCKING_REASON_CONTENT_POLICY_NO_DATA_PROTOCOL = 4001; + const uint32_t BLOCKING_REASON_CONTENT_POLICY_WEBEXT = 4002; + const uint32_t BLOCKING_REASON_CONTENT_POLICY_CONTENT_BLOCKED = 4003; + const uint32_t BLOCKING_REASON_CONTENT_POLICY_DATA_DOCUMENT = 4004; + const uint32_t BLOCKING_REASON_CONTENT_POLICY_WEB_BROWSER = 4005; + const uint32_t BLOCKING_REASON_CONTENT_POLICY_PRELOAD = 4006; + // The reason used when SEC_REQUIRE_SAME_ORIGIN_* is set and not satisifed. + const uint32_t BLOCKING_REASON_NOT_SAME_ORIGIN = 5000; + // The reason used when an extension cancels the request via the WebRequest api. + const uint32_t BLOCKING_REASON_EXTENSION_WEBREQUEST = 6000; + + /** + * If the request associated with this load info was blocked by some of + * our content or load blockers, the reason can be found here. + * Note that setting this attribute has NO EFFECT on blocking the request. + * This attribute is only informative! + * + * By default the value is '0' - NONE. + * Each write rewrites the last value. + * Can be accessed only on a single thread. + */ + [infallible] attribute unsigned long requestBlockingReason; + + /** + * The object in charged to receive CSP violation events. It can be null. + * This attribute will be merged into the CSP object eventually. + * See bug 1500908. + */ + attribute nsICSPEventListener cspEventListener; + + /** + * This attribute will be true if this is a load triggered by + * https://html.spec.whatwg.org/multipage/iframe-embed-object.html#process-the-iframe-attributes + * or https://html.spec.whatwg.org/multipage/obsolete.html#process-the-frame-attributes + */ + [infallible] readonly attribute boolean isFromProcessingFrameAttributes; + + cenum CrossOriginOpenerPolicy : 8 { + OPENER_POLICY_UNSAFE_NONE = 0, + OPENER_POLICY_SAME_ORIGIN = 1, + OPENER_POLICY_SAME_ORIGIN_ALLOW_POPUPS = 2, + OPENER_POLICY_EMBEDDER_POLICY_REQUIRE_CORP_FLAG = 0x10, + OPENER_POLICY_SAME_ORIGIN_EMBEDDER_POLICY_REQUIRE_CORP = + OPENER_POLICY_SAME_ORIGIN | + OPENER_POLICY_EMBEDDER_POLICY_REQUIRE_CORP_FLAG + }; + + cenum CrossOriginEmbedderPolicy : 8 { + EMBEDDER_POLICY_NULL = 0, + EMBEDDER_POLICY_REQUIRE_CORP = 1, + }; + + /** + * This attribute is the loading context's cross origin embedder policy. + * The value is initialized with corresponding WindowContext which get by + * innerWindowIID in the nsILoadInfo. + * It also could be set by workers when fetch is called under + * the workers' scope. + */ + [infallible] attribute nsILoadInfo_CrossOriginEmbedderPolicy + loadingEmbedderPolicy; +}; diff --git a/netwerk/base/nsIMIMEInputStream.idl b/netwerk/base/nsIMIMEInputStream.idl new file mode 100644 index 0000000000..f3411beb1a --- /dev/null +++ b/netwerk/base/nsIMIMEInputStream.idl @@ -0,0 +1,48 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsIHttpHeaderVisitor.idl" +#include "nsIInputStream.idl" + +/** + * The MIME stream separates headers and a datastream. It also allows + * automatic creation of the content-length header. + */ + +[scriptable, uuid(dcbce63c-1dd1-11b2-b94d-91f6d49a3161)] +interface nsIMIMEInputStream : nsIInputStream +{ + /** + * Adds an additional header to the stream on the form "name: value". May + * not be called once the stream has been started to be read. + * @param name name of the header + * @param value value of the header + */ + void addHeader(in string name, in string value); + + /** + * Visits all headers which have been added via addHeader. Calling + * addHeader while visiting request headers has undefined behavior. + * + * @param aVisitor + * The header visitor instance. + */ + void visitHeaders(in nsIHttpHeaderVisitor visitor); + + /** + * Sets data-stream. May not be called once the stream has been started + * to be read. + * The cursor of the new stream should be located at the beginning of the + * stream if the implementation of the nsIMIMEInputStream also is used as + * an nsISeekableStream. + * @param stream stream containing the data for the stream + */ + void setData(in nsIInputStream stream); + + /** + * Get the wrapped data stream + */ + readonly attribute nsIInputStream data; +}; diff --git a/netwerk/base/nsIMultiPartChannel.idl b/netwerk/base/nsIMultiPartChannel.idl new file mode 100644 index 0000000000..128d9c91ae --- /dev/null +++ b/netwerk/base/nsIMultiPartChannel.idl @@ -0,0 +1,49 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +interface nsIChannel; + +/** + * An interface to access the the base channel + * associated with a MultiPartChannel. + */ + +[scriptable, uuid(4fefb490-5567-11e5-a837-0800200c9a66)] +interface nsIMultiPartChannel : nsISupports +{ + /** + * readonly attribute to access the underlying channel + */ + readonly attribute nsIChannel baseChannel; + + /** + * Attribute guaranteed to be different for different parts of + * the same multipart document. + */ + readonly attribute uint32_t partID; + + /** + * Set to true when onStopRequest is received from the base channel. + * The listener can check this from its onStopRequest to determine + * whether more data can be expected. + */ + readonly attribute boolean isLastPart; +}; + +/** + * An interface that listeners can implement to receive a notification + * when the last part of the multi-part channel has finished, and the + * final OnStopRequest has been sent. + */ +[scriptable, uuid(b084959a-4fb9-41a5-88a0-d0f045ce75cf)] +interface nsIMultiPartChannelListener : nsISupports +{ + /** + * Sent when all parts have finished and sent OnStopRequest. + */ + void onAfterLastPart(in nsresult status); +}; diff --git a/netwerk/base/nsINestedURI.idl b/netwerk/base/nsINestedURI.idl new file mode 100644 index 0000000000..df124348af --- /dev/null +++ b/netwerk/base/nsINestedURI.idl @@ -0,0 +1,75 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +interface nsIURI; + +/** + * nsINestedURI is an interface that must be implemented by any nsIURI + * implementation which has an "inner" URI that it actually gets data + * from. + * + * For example, if URIs for the scheme "sanitize" have the structure: + * + * sanitize:http://example.com + * + * and opening a channel on such a sanitize: URI gets the data from + * http://example.com, sanitizes it, and returns it, then the sanitize: URI + * should implement nsINestedURI and return the http://example.com URI as its + * inner URI. + */ +[scriptable, builtinclass, uuid(6de2c874-796c-46bf-b57f-0d7bd7d6cab0)] +interface nsINestedURI : nsISupports +{ + /** + * The inner URI for this nested URI. This must not return null if the + * getter succeeds; URIs that have no inner must not QI to this interface. + * Dynamically changing whether there is an inner URI is not allowed. + * + * Modifying the returned URI must not in any way modify the nested URI; this + * means the returned URI must be either immutable or a clone. + */ + readonly attribute nsIURI innerURI; + + /** + * The innermost URI for this nested URI. This must not return null if the + * getter succeeds. This is equivalent to repeatedly calling innerURI while + * the returned URI QIs to nsINestedURI. + * + * Modifying the returned URI must not in any way modify the nested URI; this + * means the returned URI must be either immutable or a clone. + */ + readonly attribute nsIURI innermostURI; +}; + +[scriptable, builtinclass, uuid(ca3d6c03-4eee-4271-a97a-d16c0a0b2c5c)] +interface nsINestedURIMutator : nsISupports +{ + /* + * - Creates a new URI with the given innerURI. + */ + [must_use, noscript] void init(in nsIURI innerURI); +}; + +[scriptable, builtinclass, uuid(c6357a3b-c2bb-4b4b-9278-513377398a38)] +interface nsINestedAboutURIMutator : nsISupports +{ + /* + * - Creates a new URI with the given innerURI and base. + */ + [must_use, noscript] void initWithBase(in nsIURI innerURI, in nsIURI baseURI); +}; + +[scriptable, builtinclass, uuid(3bd44535-08ea-478f-99b9-85fa1084e820)] +interface nsIJSURIMutator : nsISupports +{ + /* + * - Inits the URI by setting the base URI + * - It is the caller's responsibility to also call SetSpec afterwards, + * otherwise we will return an incomplete URI (with only a base) + */ + [must_use, noscript] void setBase(in nsIURI aBaseURI); +}; diff --git a/netwerk/base/nsINetAddr.idl b/netwerk/base/nsINetAddr.idl new file mode 100644 index 0000000000..bbbcd28c0e --- /dev/null +++ b/netwerk/base/nsINetAddr.idl @@ -0,0 +1,88 @@ +/* vim: et ts=4 sw=4 tw=80 + */ +/* 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 "nsISupports.idl" + +%{ C++ +namespace mozilla { +namespace net { +union NetAddr; +} +} +%} +native NetAddr(mozilla::net::NetAddr); + +/** + * nsINetAddr + * + * This interface represents a native NetAddr struct in a readonly + * interface. + */ +[scriptable, uuid(652B9EC5-D159-45D7-9127-50BB559486CD)] +interface nsINetAddr : nsISupports +{ + /** + * @return the address family of the network address, which corresponds to + * one of the FAMILY_ constants. + */ + readonly attribute unsigned short family; + + /** + * @return Either the IP address (FAMILY_INET, FAMILY_INET6) or the path + * (FAMILY_LOCAL) in string form. IP addresses are in the format produced by + * mozilla::net::NetAddr::ToStringBuffer. + * + * Note: Paths for FAMILY_LOCAL may have length limitations which are + * implementation dependent and not documented as part of this interface. + */ + readonly attribute AUTF8String address; + + /** + * @return the port number for a FAMILY_INET or FAMILY_INET6 address. + * + * @throws NS_ERROR_NOT_AVAILABLE if the address family is not FAMILY_INET or + * FAMILY_INET6. + */ + readonly attribute unsigned short port; + + /** + * @return the flow label for a FAMILY_INET6 address. + * + * @see http://www.ietf.org/rfc/rfc3697.txt + * + * @throws NS_ERROR_NOT_AVAILABLE if the address family is not FAMILY_INET6 + */ + readonly attribute unsigned long flow; + + /** + * @return the address scope of a FAMILY_INET6 address. + * + * @see http://tools.ietf.org/html/rfc4007 + * + * @throws NS_ERROR_NOT_AVAILABLE if the address family is not FAMILY_INET6 + */ + readonly attribute unsigned long scope; + + /** + * @return whether a FAMILY_INET6 address is mapped from FAMILY_INET. + * + * @throws NS_ERROR_NOT_AVAILABLE if the address family is not FAMILY_INET6 + */ + readonly attribute boolean isV4Mapped; + + /** + * Network address families. These correspond to all the network address + * families supported by the NetAddr struct. + */ + const unsigned long FAMILY_INET = 1; + const unsigned long FAMILY_INET6 = 2; + const unsigned long FAMILY_LOCAL = 3; + + /** + * @return the underlying NetAddr struct. + */ + [noscript] NetAddr getNetAddr(); +}; diff --git a/netwerk/base/nsINetUtil.idl b/netwerk/base/nsINetUtil.idl new file mode 100644 index 0000000000..b8daa30a58 --- /dev/null +++ b/netwerk/base/nsINetUtil.idl @@ -0,0 +1,215 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +interface nsIURI; +interface nsIPrefBranch; + +/** + * nsINetUtil provides various network-related utility methods. + */ +[scriptable, uuid(fe2625ec-b884-4df1-b39c-9e830e47aa94)] +interface nsINetUtil : nsISupports +{ + /** + * Parse a Content-Type header value in strict mode. This is a more + * conservative parser that reject things that violate RFC 7231 section + * 3.1.1.1. This is typically useful for parsing Content-Type header values + * that are used for HTTP requests, and those that are used to make security + * decisions. + * + * @param aTypeHeader the header string to parse + * @param [out] aCharset the charset parameter specified in the + * header, if any. + * @param [out] aHadCharset whether a charset was explicitly specified. + * @return the MIME type specified in the header, in lower-case. + */ + AUTF8String parseRequestContentType(in AUTF8String aTypeHeader, + out AUTF8String aCharset, + out boolean aHadCharset); + + /** + * Parse a Content-Type header value in relaxed mode. This is a more + * permissive parser that ignores things that go against RFC 7231 section + * 3.1.1.1. This is typically useful for parsing Content-Type header values + * received from web servers where we want to make a best effort attempt + * at extracting a useful MIME type and charset. + * + * NOTE: DO NOT USE THIS if you're going to make security decisions + * based on the result. + * + * @param aTypeHeader the header string to parse + * @param [out] aCharset the charset parameter specified in the + * header, if any. + * @param [out] aHadCharset whether a charset was explicitly specified. + * @return the MIME type specified in the header, in lower-case. + */ + AUTF8String parseResponseContentType(in AUTF8String aTypeHeader, + out AUTF8String aCharset, + out boolean aHadCharset); + + /** + * Test whether the given URI's handler has the given protocol flags. + * + * @param aURI the URI in question + * @param aFlags the flags we're testing for. + * + * @return whether the protocol handler for aURI has all the flags + * in aFlags. + */ + boolean protocolHasFlags(in nsIURI aURI, in unsigned long aFlag); + + /** + * Test whether the protocol handler for this URI or that for any of + * its inner URIs has the given protocol flags. This will QI aURI to + * nsINestedURI and walk the nested URI chain. + * + * @param aURI the URI in question + * @param aFlags the flags we're testing for. + * + * @return whether any of the protocol handlers involved have all the flags + * in aFlags. + */ + boolean URIChainHasFlags(in nsIURI aURI, in unsigned long aFlags); + + /** Escape every character with its %XX-escaped equivalent */ + const unsigned long ESCAPE_ALL = 0; + + /** Leave alphanumeric characters intact and %XX-escape all others */ + const unsigned long ESCAPE_XALPHAS = 1; + + /** Leave alphanumeric characters intact, convert spaces to '+', + %XX-escape all others */ + const unsigned long ESCAPE_XPALPHAS = 2; + + /** Leave alphanumeric characters and forward slashes intact, + %XX-escape all others */ + const unsigned long ESCAPE_URL_PATH = 4; + + /** + * escape a string with %00-style escaping + */ + ACString escapeString(in ACString aString, in unsigned long aEscapeType); + + /** %XX-escape URL scheme */ + const unsigned long ESCAPE_URL_SCHEME = 1; + + /** %XX-escape username in the URL */ + const unsigned long ESCAPE_URL_USERNAME = 1 << 1; + + /** %XX-escape password in the URL */ + const unsigned long ESCAPE_URL_PASSWORD = 1 << 2; + + /** %XX-escape URL host */ + const unsigned long ESCAPE_URL_HOST = 1 << 3; + + /** %XX-escape URL directory */ + const unsigned long ESCAPE_URL_DIRECTORY = 1 << 4; + + /** %XX-escape file basename in the URL */ + const unsigned long ESCAPE_URL_FILE_BASENAME = 1 << 5; + + /** %XX-escape file extension in the URL */ + const unsigned long ESCAPE_URL_FILE_EXTENSION = 1 << 6; + + /** %XX-escape URL parameters */ + const unsigned long ESCAPE_URL_PARAM = 1 << 7; + + /** %XX-escape URL query */ + const unsigned long ESCAPE_URL_QUERY = 1 << 8; + + /** %XX-escape URL ref */ + const unsigned long ESCAPE_URL_REF = 1 << 9; + + /** %XX-escape URL path - same as escaping directory, basename and extension */ + const unsigned long ESCAPE_URL_FILEPATH = + ESCAPE_URL_DIRECTORY | ESCAPE_URL_FILE_BASENAME | ESCAPE_URL_FILE_EXTENSION; + + /** %XX-escape scheme, username, password, host, path, params, query and ref */ + const unsigned long ESCAPE_URL_MINIMAL = + ESCAPE_URL_SCHEME | ESCAPE_URL_USERNAME | ESCAPE_URL_PASSWORD | + ESCAPE_URL_HOST | ESCAPE_URL_FILEPATH | ESCAPE_URL_PARAM | + ESCAPE_URL_QUERY | ESCAPE_URL_REF; + + /** Force %XX-escaping of already escaped sequences */ + const unsigned long ESCAPE_URL_FORCED = 1 << 10; + + /** Skip non-ascii octets, %XX-escape all others */ + const unsigned long ESCAPE_URL_ONLY_ASCII = 1 << 11; + + /** + * Skip graphic octets (0x20-0x7E) when escaping + * Skips all ASCII octets (0x00-0x7F) when unescaping + */ + const unsigned long ESCAPE_URL_ONLY_NONASCII = 1 << 12; + + /** Force %XX-escape of colon */ + const unsigned long ESCAPE_URL_COLON = 1 << 14; + + /** Skip C0 and DEL from unescaping */ + const unsigned long ESCAPE_URL_SKIP_CONTROL = 1 << 15; + + /** + * %XX-Escape invalid chars in a URL segment. + * + * @param aStr the URL to be escaped + * @param aFlags the URL segment type flags + * + * @return the escaped string (the string itself if escaping did not happen) + * + */ + ACString escapeURL(in ACString aStr, in unsigned long aFlags); + + /** + * Expands URL escape sequences + * + * @param aStr the URL to be unescaped + * @param aFlags only ESCAPE_URL_ONLY_NONASCII and ESCAPE_URL_SKIP_CONTROL + * are recognized. If |aFlags| is 0 all escape sequences are + * unescaped + * @return unescaped string + */ + ACString unescapeString(in AUTF8String aStr, in unsigned long aFlags); + + /** + * Extract the charset parameter location and value from a content-type + * header. + * + * @param aTypeHeader the header string to parse + * @param [out] aCharset the charset parameter specified in the + * header, if any. + * @param [out] aCharsetStart index of the start of the charset parameter + * (the ';' separating it from what came before) in aTypeHeader. + * If this function returns false, this argument will still be + * set, to the index of the location where a new charset should + * be inserted. + * @param [out] aCharsetEnd index of the end of the charset parameter (the + * ';' separating it from what comes after, or the end + * of the string) in aTypeHeader. If this function returns + * false, this argument will still be set, to the index of the + * location where a new charset should be inserted. + * + * @return whether a charset parameter was found. This can be false even in + * cases when parseContentType would claim to have a charset, if the type + * that won out does not have a charset parameter specified. + */ + boolean extractCharsetFromContentType(in AUTF8String aTypeHeader, + out AUTF8String aCharset, + out long aCharsetStart, + out long aCharsetEnd); + + /** + * This is test-only. Send an IPC message to let socket process send a + * telemetry. + */ + void socketProcessTelemetryPing(); + + /** + * This is a void method that is C++ implemented and always + * returns NS_ERROR_NOT_IMPLEMENTED. To be used for testing. + */ + void notImplemented(); +}; diff --git a/netwerk/base/nsINetworkConnectivityService.idl b/netwerk/base/nsINetworkConnectivityService.idl new file mode 100644 index 0000000000..482eaf45ee --- /dev/null +++ b/netwerk/base/nsINetworkConnectivityService.idl @@ -0,0 +1,44 @@ +/* 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 "nsISupports.idl" + +[scriptable, builtinclass, uuid(2693457e-3ba5-4455-991f-5350946adb12)] +interface nsINetworkConnectivityService : nsISupports +{ + /** + * Each tested feature may be in one of 3 states: + * UNKNOWN, if a check hasn't been performed. + * OK, if the feature was successfully tested + * NOT_AVAILABLE, if the feature is blocked by the network. + * Note that the endpoints are guaranteed to support the features. + */ + cenum ConnectivityState: 32 { + UNKNOWN = 0, + OK = 1, + NOT_AVAILABLE = 2 + }; + + /* If DNS v4/v6 queries actually work on the current network */ + [infallible] + readonly attribute nsINetworkConnectivityService_ConnectivityState DNSv4; + [infallible] + readonly attribute nsINetworkConnectivityService_ConnectivityState DNSv6; + + /* If connecting to IPv4/v6 works on the current network */ + [infallible] + readonly attribute nsINetworkConnectivityService_ConnectivityState IPv4; + [infallible] + readonly attribute nsINetworkConnectivityService_ConnectivityState IPv6; + + /* If a NAT64 gateway was detected on the current network */ + [infallible] + readonly attribute nsINetworkConnectivityService_ConnectivityState NAT64; + + /* Starts the DNS request to check for DNS v4/v6 availability */ + void recheckDNS(); + + /* Starts HTTP requests over IPv4 and IPv6, and checks if they work */ + void recheckIPConnectivity(); +}; diff --git a/netwerk/base/nsINetworkInfoService.idl b/netwerk/base/nsINetworkInfoService.idl new file mode 100644 index 0000000000..9349abe13f --- /dev/null +++ b/netwerk/base/nsINetworkInfoService.idl @@ -0,0 +1,56 @@ +/* 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 "nsISupports.idl" + +/** + * Listener for getting list of addresses. + */ +[scriptable, uuid(c4bdaac1-3ab1-4fdb-9a16-17cbed794603)] +interface nsIListNetworkAddressesListener : nsISupports +{ + /** + * Callback function that gets called by nsINetworkInfoService.listNetworkAddresses. + * Each address in the array is a string IP address in canonical form, + * e.g. 192.168.1.10, or an IPV6 address in string form. + */ + void onListedNetworkAddresses(in Array<ACString> aAddressArray); + void onListNetworkAddressesFailed(); +}; + +/** + * Listener for getting hostname. + */ +[scriptable, uuid(3ebdcb62-2df4-4042-8864-3fa81abd4693)] +interface nsIGetHostnameListener : nsISupports +{ + void onGotHostname(in AUTF8String aHostname); + void onGetHostnameFailed(); +}; + +/** + * Service information + */ +[scriptable, uuid(55fc8dae-4a58-4e0f-a49b-901cbabae809)] +interface nsINetworkInfoService : nsISupports +{ + /** + * Obtain a list of local machine network addresses. The listener object's + * onListedNetworkAddresses will be called with the obtained addresses. + * On failure, the listener object's onListNetworkAddressesFailed() will be called. + */ + void listNetworkAddresses(in nsIListNetworkAddressesListener aListener); + + /** + * Obtain the hostname of the local machine. The listener object's + * onGotHostname will be called with the obtained hostname. + * On failure, the listener object's onGetHostnameFailed() will be called. + */ + void getHostname(in nsIGetHostnameListener aListener); +}; + +%{ C++ +#define NETWORKINFOSERVICE_CONTRACT_ID \ + "@mozilla.org/network-info-service;1" +%} diff --git a/netwerk/base/nsINetworkInterceptController.idl b/netwerk/base/nsINetworkInterceptController.idl new file mode 100644 index 0000000000..64a4a71b03 --- /dev/null +++ b/netwerk/base/nsINetworkInterceptController.idl @@ -0,0 +1,264 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" +#include "nsIContentPolicy.idl" + +interface nsICacheInfoChannel; +interface nsIChannel; +interface nsIConsoleReportCollector; +interface nsIInputStream; +interface nsIOutputStream; +interface nsIURI; + +%{C++ +#include "nsContentUtils.h" +#include "nsIChannel.h" +#include "nsIConsoleReportCollector.h" +#include "nsILoadInfo.h" +namespace mozilla { +class TimeStamp; + +namespace dom { +class ChannelInfo; +} +} +%} + +native TimeStamp(mozilla::TimeStamp); + +[ptr] native ChannelInfo(mozilla::dom::ChannelInfo); + +/** + * Interface allowing the nsIInterceptedChannel to callback when it is + * done reading from the body stream. + */ +[scriptable, uuid(51039eb6-bea0-40c7-b523-ccab56cc4fde)] +interface nsIInterceptedBodyCallback : nsISupports +{ + void bodyComplete(in nsresult aRv); +}; + +/** + * Interface to allow implementors of nsINetworkInterceptController to control the behaviour + * of intercepted channels without tying implementation details of the interception to + * the actual channel. nsIInterceptedChannel is expected to be implemented by objects + * which do not implement nsIChannel. + */ + +[scriptable, uuid(f4b82975-6a86-4cc4-87fe-9a1fd430c86d)] +interface nsIInterceptedChannel : nsISupports +{ + /** + * Instruct a channel that has been intercepted to continue with the original + * network request. + */ + void resetInterception(); + + /** + * Set the status and reason for the forthcoming synthesized response. + * Multiple calls overwrite existing values. + */ + void synthesizeStatus(in uint16_t status, in ACString reason); + + /** + * Attach a header name/value pair to the forthcoming synthesized response. + * Overwrites any existing header value. + */ + void synthesizeHeader(in ACString name, in ACString value); + + /** + * Instruct a channel that has been intercepted that a response is + * starting to be synthesized. No further header modification is allowed + * after this point. There are a few parameters: + * - A body stream may be optionally passed. If nullptr, then an + * empty body is assumed. + * - A callback may be optionally passed. It will be invoked + * when the body is complete. For a nullptr body this may be + * synchronously on the current thread. Otherwise it will be invoked + * asynchronously on the current thread. + * - A cacheInfoChannel may be optionally passed. If the body stream is + * from alternative data cache, this cacheInfoChannel provides needed + * cache information. + * - The caller may optionally pass a spec for a URL that this response + * originates from; an empty string will cause the original + * intercepted request's URL to be used instead. + * - The responseRedirected flag is false will cause the channel do an + * internal redirect when the original intercepted reauest's URL is + * different from the response's URL. The flag is true will cause the + * chaanel do a non-internal redirect when the URLs are different. + */ + void startSynthesizedResponse(in nsIInputStream body, + in nsIInterceptedBodyCallback callback, + in nsICacheInfoChannel channel, + in ACString finalURLSpec, + in bool responseRedirected); + + /** + * Instruct a channel that has been intercepted that response synthesis + * has completed and all outstanding resources can be closed. + */ + void finishSynthesizedResponse(); + + /** + * Cancel the pending intercepted request. + * @return NS_ERROR_FAILURE if the response has already been synthesized or + * the original request has been instructed to continue. + */ + void cancelInterception(in nsresult status); + + /** + * The underlying channel object that was intercepted. + */ + readonly attribute nsIChannel channel; + + /** + * The URL of the underlying channel object, corrected for a potential + * secure upgrade. + */ + readonly attribute nsIURI secureUpgradedChannelURI; + + /** + * This method allows to override the channel info for the channel. + */ + [noscript] + void setChannelInfo(in ChannelInfo channelInfo); + + /** + * Get the internal load type from the underlying channel. + */ + [noscript] + readonly attribute nsContentPolicyType internalContentPolicyType; + + [noscript] + readonly attribute nsIConsoleReportCollector consoleReportCollector; + + /** + * Save the timestamps of various service worker interception phases. + */ + [noscript] + void SetLaunchServiceWorkerStart(in TimeStamp aTimeStamp); + + // A hack to get sw launch start time for telemetry. + [noscript] + void GetLaunchServiceWorkerStart(out TimeStamp aTimeStamp); + + [noscript] + void SetLaunchServiceWorkerEnd(in TimeStamp aTimeStamp); + + // A hack to get sw launch end time for telemetry. + [noscript] + void GetLaunchServiceWorkerEnd(out TimeStamp aTimeStamp); + + [noscript] + void SetDispatchFetchEventStart(in TimeStamp aTimeStamp); + + [noscript] + void SetDispatchFetchEventEnd(in TimeStamp aTimeStamp); + + [noscript] + void SetHandleFetchEventStart(in TimeStamp aTimeStamp); + + [noscript] + void SetHandleFetchEventEnd(in TimeStamp aTimeStamp); + + // Depending on the outcome we measure the time difference between + // |FinishResponseStart| and either |FinishSynthesizedResponseEnd| or + // |ChannelResetEnd|. + [noscript] + void SetFinishResponseStart(in TimeStamp aTimeStamp); + + [noscript] + void SetFinishSynthesizedResponseEnd(in TimeStamp aTimeStamp); + + [noscript] + void SetChannelResetEnd(in TimeStamp aTimeStamp); + + [noscript] + void SaveTimeStamps(); + +%{C++ + already_AddRefed<nsIConsoleReportCollector> + GetConsoleReportCollector() + { + nsCOMPtr<nsIConsoleReportCollector> reporter; + GetConsoleReportCollector(getter_AddRefs(reporter)); + return reporter.forget(); + } + + void + GetSubresourceTimeStampKey(nsIChannel* aChannel, nsACString& aKey) + { + if (!nsContentUtils::IsNonSubresourceRequest(aChannel)) { + nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo(); + switch(loadInfo->InternalContentPolicyType()) { + case nsIContentPolicy::TYPE_SCRIPT: + case nsIContentPolicy::TYPE_INTERNAL_SCRIPT: + case nsIContentPolicy::TYPE_INTERNAL_SCRIPT_PRELOAD: + case nsIContentPolicy::TYPE_INTERNAL_MODULE: + case nsIContentPolicy::TYPE_INTERNAL_MODULE_PRELOAD: + case nsIContentPolicy::TYPE_INTERNAL_WORKER_IMPORT_SCRIPTS: { + aKey = "subresource-script"_ns; + break; + } + case nsIContentPolicy::TYPE_IMAGE: + case nsIContentPolicy::TYPE_INTERNAL_IMAGE: + case nsIContentPolicy::TYPE_INTERNAL_IMAGE_PRELOAD: + case nsIContentPolicy::TYPE_INTERNAL_IMAGE_FAVICON: { + aKey = "subresource-image"_ns; + break; + } + case nsIContentPolicy::TYPE_STYLESHEET: + case nsIContentPolicy::TYPE_INTERNAL_STYLESHEET: + case nsIContentPolicy::TYPE_INTERNAL_STYLESHEET_PRELOAD: { + aKey = "subresource-stylesheet"_ns; + break; + } + default: { + aKey = "subresource-other"_ns; + break; + } + } + } + } +%} + + /** + * Allow the ServiceWorkerManager to set an RAII-style object on the + * intercepted channel that should be released once the channel is + * torn down. + */ + [noscript] + void setReleaseHandle(in nsISupports aHandle); +}; + +/** + * Interface to allow consumers to attach themselves to a channel's + * notification callbacks/loadgroup and determine if a given channel + * request should be intercepted before any network request is initiated. + */ + +[scriptable, uuid(70d2b4fe-a552-48cd-8d93-1d8437a56b53)] +interface nsINetworkInterceptController : nsISupports +{ + /** + * Returns true if a channel should avoid initiating any network + * requests until specifically instructed to do so. + * + * @param aURI The URI to be loaded. Note, this may differ from + * the channel's current URL in some cases. + * @param aChannel The channel that may be intercepted. It will + * be in the state prior to calling OnStartRequest(). + */ + bool shouldPrepareForIntercept(in nsIURI aURI, in nsIChannel aChannel); + + /** + * Notification when a given intercepted channel is prepared to accept a synthesized + * response via the provided stream. + * + * @param aChannel the controlling interface for a channel that has been intercepted + */ + void channelIntercepted(in nsIInterceptedChannel aChannel); +}; diff --git a/netwerk/base/nsINetworkLinkService.idl b/netwerk/base/nsINetworkLinkService.idl new file mode 100644 index 0000000000..eb5f541932 --- /dev/null +++ b/netwerk/base/nsINetworkLinkService.idl @@ -0,0 +1,140 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* vim:expandtab:shiftwidth=4:tabstop=4: + */ +/* 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 "nsISupports.idl" + +/** + * Network link status monitoring service. + */ +[scriptable, uuid(103e5293-77b3-4b70-af59-6e9e4a1f994a)] +interface nsINetworkLinkService : nsISupports +{ + /* Link type constants */ + const unsigned long LINK_TYPE_UNKNOWN = 0; + const unsigned long LINK_TYPE_ETHERNET = 1; + const unsigned long LINK_TYPE_USB = 2; + const unsigned long LINK_TYPE_WIFI = 3; + const unsigned long LINK_TYPE_WIMAX = 4; + const unsigned long LINK_TYPE_2G = 5; + const unsigned long LINK_TYPE_3G = 6; + const unsigned long LINK_TYPE_4G = 7; + + /** + * This is set to true when the system is believed to have a usable + * network connection. + * + * The link is only up when network connections can be established. For + * example, the link is down during DHCP configuration (unless there + * is another usable interface already configured). + * + * If the link status is not currently known, we generally assume that + * it is up. + */ + readonly attribute boolean isLinkUp; + + /** + * This is set to true when we believe that isLinkUp is accurate. + */ + readonly attribute boolean linkStatusKnown; + + /** + * The type of network connection. + */ + readonly attribute unsigned long linkType; + + /** + * A string uniquely identifying the current active network interfaces. + * Empty when there are no active network interfaces. + */ + readonly attribute ACString networkID; + + /** + * The list of DNS suffixes for the currently active network interfaces. + */ + readonly attribute Array<ACString> dnsSuffixList; + + const unsigned long NONE_DETECTED = 0; + const unsigned long VPN_DETECTED = 1 << 0; + const unsigned long PROXY_DETECTED = 1 << 1; + const unsigned long NRPT_DETECTED = 1 << 2; + + /** + * A bitfield that encodes the platform attributes we detected which + * indicate that we should only use DNS, not TRR. + */ + readonly attribute unsigned long platformDNSIndications; +}; + +%{C++ +/** + * We send notifications through nsIObserverService with topic + * NS_NETWORK_LINK_TOPIC whenever one of isLinkUp or linkStatusKnown + * changes. We pass one of the NS_NETWORK_LINK_DATA_ constants below + * as the aData parameter of the notification. + */ +#define NS_NETWORK_LINK_TOPIC "network:link-status-changed" + +/** + * isLinkUp is now true, linkStatusKnown is true. + */ +#define NS_NETWORK_LINK_DATA_UP "up" +/** + * isLinkUp is now false, linkStatusKnown is true. + */ +#define NS_NETWORK_LINK_DATA_DOWN "down" +/** + * isLinkUp is still true, but the network setup is modified. + * linkStatusKnown is true. + */ +#define NS_NETWORK_LINK_DATA_CHANGED "changed" +/** + * linkStatusKnown is now false. + */ +#define NS_NETWORK_LINK_DATA_UNKNOWN "unknown" + +/** + * network ID has changed. + */ +#define NS_NETWORK_ID_CHANGED_TOPIC "network:networkid-changed" + +/** + * DNS suffix list has updated. + */ +#define NS_DNS_SUFFIX_LIST_UPDATED_TOPIC "network:dns-suffix-list-updated" + +/** + * We send notifications through nsIObserverService with topic + * NS_NETWORK_LINK_TYPE_TOPIC whenever the network connection type + * changes. We pass one of the valid connection type constants + * below as the aData parameter of the notification. + */ +#define NS_NETWORK_LINK_TYPE_TOPIC "network:link-type-changed" + +/** We were unable to determine the network connection type */ +#define NS_NETWORK_LINK_TYPE_UNKNOWN "unknown" + +/** A standard wired ethernet connection */ +#define NS_NETWORK_LINK_TYPE_ETHERNET "ethernet" + +/** A connection via a USB port */ +#define NS_NETWORK_LINK_TYPE_USB "usb" + +/** A connection via a WiFi access point (IEEE802.11) */ +#define NS_NETWORK_LINK_TYPE_WIFI "wifi" + +/** A connection via WiMax (IEEE802.16) */ +#define NS_NETWORK_LINK_TYPE_WIMAX "wimax" + +/** A '2G' mobile connection (e.g. GSM, GPRS, EDGE) */ +#define NS_NETWORK_LINK_TYPE_2G "2g" + +/** A '3G' mobile connection (e.g. UMTS, CDMA) */ +#define NS_NETWORK_LINK_TYPE_3G "3g" + +/** A '4G' mobile connection (e.g. LTE, UMB) */ +#define NS_NETWORK_LINK_TYPE_4G "4g" +%} diff --git a/netwerk/base/nsINetworkPredictor.idl b/netwerk/base/nsINetworkPredictor.idl new file mode 100644 index 0000000000..07f88cba8d --- /dev/null +++ b/netwerk/base/nsINetworkPredictor.idl @@ -0,0 +1,194 @@ +/* vim: set ts=2 sts=2 et sw=2: */ +/* 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 "nsISupports.idl" + +interface nsIURI; +interface nsINetworkPredictorVerifier; + +webidl Document; + +typedef unsigned long PredictorPredictReason; +typedef unsigned long PredictorLearnReason; + +%{C++ +namespace mozilla { + +class OriginAttributes; + +} +%} + +[ref] native OriginAttributes(const mozilla::OriginAttributes); + +/** + * nsINetworkPredictor - learn about pages users visit, and allow us to take + * predictive actions upon future visits. + * NOTE: nsINetworkPredictor should only + * be used on the main thread. + */ +[scriptable, builtinclass, uuid(acc88e7c-3f39-42c7-ac31-6377c2c3d73e)] +interface nsINetworkPredictor : nsISupports +{ + /** + * Prediction reasons + * + * PREDICT_LINK - we are being asked to take predictive action because + * the user is hovering over a link. + * + * PREDICT_LOAD - we are being asked to take predictive action because + * the user has initiated a pageload. + * + * PREDICT_STARTUP - we are being asked to take predictive action + * because the browser is starting up. + */ + const PredictorPredictReason PREDICT_LINK = 0; + const PredictorPredictReason PREDICT_LOAD = 1; + const PredictorPredictReason PREDICT_STARTUP = 2; + + /** + * Start taking predictive actions + * + * Calling this will cause the predictor to (possibly) start + * taking actions such as DNS prefetch and/or TCP preconnect based on + * (1) the host name that we are given, and (2) the reason we are being + * asked to take actions. + * + * @param targetURI - The URI we are being asked to take actions based on. + * @param sourceURI - The URI that is currently loaded. This is so we can + * avoid doing predictive actions for link hover on an HTTPS page (for + * example). + * @param reason - The reason we are being asked to take actions. Can be + * any of the PREDICT_* values above. + * In the case of PREDICT_LINK, targetURI should be the URI of the link + * that is being hovered over, and sourceURI should be the URI of the page + * on which the link appears. + * In the case of PREDICT_LOAD, targetURI should be the URI of the page that + * is being loaded and sourceURI should be null. + * In the case of PREDICT_STARTUP, both targetURI and sourceURI should be + * null. + * @param originAttributes - The originAttributes of the page load we are + * predicting about. + * @param verifier - An nsINetworkPredictorVerifier used in testing to ensure + * we're predicting the way we expect to. Not necessary (or desired) for + * normal operation. + */ + [implicit_jscontext] + void predict(in nsIURI targetURI, + in nsIURI sourceURI, + in PredictorPredictReason reason, + in jsval originAttributes, + in nsINetworkPredictorVerifier verifier); + + [notxpcom] + nsresult predictNative(in nsIURI targetURI, + in nsIURI sourceURI, + in PredictorPredictReason reason, + in OriginAttributes originAttributes, + in nsINetworkPredictorVerifier verifier); + + + /* + * Reasons we are learning something + * + * LEARN_LOAD_TOPLEVEL - we are learning about the toplevel resource of a + * pageload (NOTE: this should ONLY be used by tests) + * + * LEARN_LOAD_SUBRESOURCE - we are learning a subresource from a pageload + * + * LEARN_LOAD_REDIRECT - we are learning about the re-direct of a URI + * + * LEARN_STARTUP - we are learning about a page loaded during startup + */ + const PredictorLearnReason LEARN_LOAD_TOPLEVEL = 0; + const PredictorLearnReason LEARN_LOAD_SUBRESOURCE = 1; + const PredictorLearnReason LEARN_LOAD_REDIRECT = 2; + const PredictorLearnReason LEARN_STARTUP = 3; + + /** + * Add to our compendium of knowledge + * + * This adds to our prediction database to make things (hopefully) + * smarter next time we predict something. + * + * @param targetURI - The URI that was loaded that we are keeping track of. + * @param sourceURI - The URI that caused targetURI to be loaded (for page + * loads). This means the DOCUMENT URI. + * @param reason - The reason we are learning this bit of knowledge. + * Reason can be any of the LEARN_* values. + * In the case of LEARN_LOAD_SUBRESOURCE, targetURI should be the URI of a + * subresource of a page, and sourceURI should be the top-level URI. + * In the case of LEARN_LOAD_REDIRECT, targetURI is the NEW URI of a + * top-level resource that was redirected to, and sourceURI is the + * ORIGINAL URI of said top-level resource. + * In the case of LEARN_STARTUP, targetURI should be the URI of a page + * that was loaded immediately after browser startup, and sourceURI should + * be null. + * @param originAttributes - The originAttributes for the page load that we + * are learning about. + */ + [implicit_jscontext] + void learn(in nsIURI targetURI, + in nsIURI sourceURI, + in PredictorLearnReason reason, + in jsval originAttributes); + + [notxpcom] + nsresult learnNative(in nsIURI targetURI, + in nsIURI sourceURI, + in PredictorLearnReason reason, + in OriginAttributes originAttributes); + + /** + * Clear out all our learned knowledge + * + * This removes everything from our database so that any predictions begun + * after this completes will start from a blank slate. + */ + void reset(); +}; + +%{C++ +// Wrapper functions to make use of the predictor easier and less invasive +class nsIChannel; + +class nsILoadContext; +class nsILoadGroup; +class nsINetworkPredictorVerifier; + +namespace mozilla { + +class OriginAttributes; + +namespace net { + +nsresult PredictorPredict(nsIURI *targetURI, + nsIURI *sourceURI, + PredictorPredictReason reason, + const OriginAttributes& originAttributes, + nsINetworkPredictorVerifier *verifier); + +nsresult PredictorLearn(nsIURI *targetURI, + nsIURI *sourceURI, + PredictorLearnReason reason, + const OriginAttributes& originAttributes); + +nsresult PredictorLearn(nsIURI *targetURI, + nsIURI *sourceURI, + PredictorLearnReason reason, + nsILoadGroup *loadGroup); + +nsresult PredictorLearn(nsIURI *targetURI, + nsIURI *sourceURI, + PredictorLearnReason reason, + dom::Document *document); + +nsresult PredictorLearnRedirect(nsIURI *targetURI, + nsIChannel *channel, + const OriginAttributes& originAttributes); + +} // mozilla::net +} // mozilla +%} diff --git a/netwerk/base/nsINetworkPredictorVerifier.idl b/netwerk/base/nsINetworkPredictorVerifier.idl new file mode 100644 index 0000000000..b00aecc076 --- /dev/null +++ b/netwerk/base/nsINetworkPredictorVerifier.idl @@ -0,0 +1,40 @@ +/* vim: set ts=2 sts=2 et sw=2: */ +/* 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/. */ + +/** + * nsINetworkPredictorVerifier - used for testing the network predictor to + * ensure it does what we expect it to do. + */ + +#include "nsISupports.idl" + +interface nsIURI; + +[scriptable, uuid(2e43bb32-dabf-4494-9f90-2b3195b1c73d)] +interface nsINetworkPredictorVerifier : nsISupports +{ + /** + * Callback for when we do a predictive prefetch + * + * @param uri - The URI that was prefetched + * @param status - The request status code returned by the + * prefetch attempt e.g. 200 (OK):w + */ + void onPredictPrefetch(in nsIURI uri, in uint32_t status); + + /** + * Callback for when we do a predictive preconnect + * + * @param uri - The URI that was preconnected to + */ + void onPredictPreconnect(in nsIURI uri); + + /** + * Callback for when we do a predictive DNS lookup + * + * @param uri - The URI that was looked up + */ + void onPredictDNS(in nsIURI uri); +}; diff --git a/netwerk/base/nsINullChannel.idl b/netwerk/base/nsINullChannel.idl new file mode 100644 index 0000000000..6c03a2743b --- /dev/null +++ b/netwerk/base/nsINullChannel.idl @@ -0,0 +1,16 @@ +/* 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 "nsISupports.idl" + +/** + * This interface is only used in order to mark the fact that + * an object isn't a complete implementation of its interfaces. + * For example, a consumer can QI NullHttpChannel to nsINullChannel, + * to determine if the object is just a dummy implementation of nsIHttpChannel. + */ +[scriptable, builtinclass, uuid(4610b901-df41-4bb4-bd3f-fd4d6b6d8d68)] +interface nsINullChannel : nsISupports +{ +}; diff --git a/netwerk/base/nsIOService.cpp b/netwerk/base/nsIOService.cpp new file mode 100644 index 0000000000..1476671f00 --- /dev/null +++ b/netwerk/base/nsIOService.cpp @@ -0,0 +1,2039 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=4 sw=2 cindent et: */ +/* 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 "mozilla/DebugOnly.h" + +#include "nsIOService.h" +#include "nsIProtocolHandler.h" +#include "nsIFileProtocolHandler.h" +#include "nscore.h" +#include "nsIURI.h" +#include "prprf.h" +#include "nsErrorService.h" +#include "netCore.h" +#include "nsIObserverService.h" +#include "nsXPCOM.h" +#include "nsIProxiedProtocolHandler.h" +#include "nsIProxyInfo.h" +#include "nsEscape.h" +#include "nsNetUtil.h" +#include "nsNetCID.h" +#include "nsCRT.h" +#include "nsSimpleNestedURI.h" +#include "nsTArray.h" +#include "nsIConsoleService.h" +#include "nsIUploadChannel2.h" +#include "nsXULAppAPI.h" +#include "nsIProtocolProxyCallback.h" +#include "nsICancelable.h" +#include "nsINetworkLinkService.h" +#include "nsAsyncRedirectVerifyHelper.h" +#include "nsURLHelper.h" +#include "nsIProtocolProxyService2.h" +#include "MainThreadUtils.h" +#include "nsINode.h" +#include "nsIWidget.h" +#include "nsThreadUtils.h" +#include "mozilla/LoadInfo.h" +#include "mozilla/net/NeckoCommon.h" +#include "mozilla/Services.h" +#include "mozilla/Telemetry.h" +#include "mozilla/net/DNS.h" +#include "mozilla/ipc/URIUtils.h" +#include "mozilla/net/NeckoChild.h" +#include "mozilla/net/NeckoParent.h" +#include "mozilla/dom/ClientInfo.h" +#include "mozilla/dom/ContentParent.h" +#include "mozilla/dom/ServiceWorkerDescriptor.h" +#include "mozilla/net/CaptivePortalService.h" +#include "mozilla/net/NetworkConnectivityService.h" +#include "mozilla/net/SocketProcessHost.h" +#include "mozilla/net/SocketProcessParent.h" +#include "mozilla/net/SSLTokensCache.h" +#include "mozilla/Unused.h" +#include "nsContentSecurityManager.h" +#include "nsContentUtils.h" +#include "nsExceptionHandler.h" +#include "mozilla/StaticPrefs_network.h" +#include "mozilla/StaticPrefs_security.h" +#include "nsNSSComponent.h" +#include "ssl.h" + +#ifdef MOZ_WIDGET_GTK +# include "nsGIOProtocolHandler.h" +#endif + +namespace mozilla { +namespace net { + +using mozilla::Maybe; +using mozilla::dom::ClientInfo; +using mozilla::dom::ServiceWorkerDescriptor; + +#define PORT_PREF_PREFIX "network.security.ports." +#define PORT_PREF(x) PORT_PREF_PREFIX x +#define MANAGE_OFFLINE_STATUS_PREF "network.manage-offline-status" + +// Nb: these have been misnomers since bug 715770 removed the buffer cache. +// "network.segment.count" and "network.segment.size" would be better names, +// but the old names are still used to preserve backward compatibility. +#define NECKO_BUFFER_CACHE_COUNT_PREF "network.buffer.cache.count" +#define NECKO_BUFFER_CACHE_SIZE_PREF "network.buffer.cache.size" +#define NETWORK_CAPTIVE_PORTAL_PREF "network.captive-portal-service.enabled" +#define WEBRTC_PREF_PREFIX "media.peerconnection." +#define NETWORK_DNS_PREF "network.dns." + +#define MAX_RECURSION_COUNT 50 + +nsIOService* gIOService; +static bool gHasWarnedUploadChannel2; +static bool gCaptivePortalEnabled = false; +static LazyLogModule gIOServiceLog("nsIOService"); +#undef LOG +#define LOG(args) MOZ_LOG(gIOServiceLog, LogLevel::Debug, args) + +// A general port blacklist. Connections to these ports will not be allowed +// unless the protocol overrides. +// +// This list is to be kept in sync with "bad ports" as defined in the +// WHATWG Fetch standard at <https://fetch.spec.whatwg.org/#port-blocking> + +int16_t gBadPortList[] = { + 1, // tcpmux + 7, // echo + 9, // discard + 11, // systat + 13, // daytime + 15, // netstat + 17, // qotd + 19, // chargen + 20, // ftp-data + 21, // ftp + 22, // ssh + 23, // telnet + 25, // smtp + 37, // time + 42, // name + 43, // nicname + 53, // domain + 69, // tftp + 77, // priv-rjs + 79, // finger + 87, // ttylink + 95, // supdup + 101, // hostriame + 102, // iso-tsap + 103, // gppitnp + 104, // acr-nema + 109, // pop2 + 110, // pop3 + 111, // sunrpc + 113, // auth + 115, // sftp + 117, // uucp-path + 119, // nntp + 123, // ntp + 135, // loc-srv / epmap + 137, // netbios + 139, // netbios + 143, // imap2 + 161, // snmp + 179, // bgp + 389, // ldap + 427, // afp (alternate) + 465, // smtp (alternate) + 512, // print / exec + 513, // login + 514, // shell + 515, // printer + 526, // tempo + 530, // courier + 531, // chat + 532, // netnews + 540, // uucp + 548, // afp + 554, // rtsp + 556, // remotefs + 563, // nntp+ssl + 587, // smtp (outgoing) + 601, // syslog-conn + 636, // ldap+ssl + 993, // imap+ssl + 995, // pop3+ssl + 1719, // h323gatestat + 1720, // h323hostcall + 1723, // pptp + 2049, // nfs + 3659, // apple-sasl + 4045, // lockd + 5060, // sip + 5061, // sips + 6000, // x11 + 6566, // sane-port + 6665, // irc (alternate) + 6666, // irc (alternate) + 6667, // irc (default) + 6668, // irc (alternate) + 6669, // irc (alternate) + 6697, // irc+tls + 10080, // amanda + 0, // Sentinel value: This MUST be zero +}; + +static const char kProfileChangeNetTeardownTopic[] = + "profile-change-net-teardown"; +static const char kProfileChangeNetRestoreTopic[] = + "profile-change-net-restore"; +static const char kProfileDoChange[] = "profile-do-change"; + +// Necko buffer defaults +uint32_t nsIOService::gDefaultSegmentSize = 4096; +uint32_t nsIOService::gDefaultSegmentCount = 24; + +//////////////////////////////////////////////////////////////////////////////// + +nsIOService::nsIOService() + : mOffline(true), + mOfflineForProfileChange(false), + mManageLinkStatus(false), + mConnectivity(true), + mSettingOffline(false), + mSetOfflineValue(false), + mSocketProcessLaunchComplete(false), + mShutdown(false), + mHttpHandlerAlreadyShutingDown(false), + mNetworkLinkServiceInitialized(false), + mChannelEventSinks(NS_CHANNEL_EVENT_SINK_CATEGORY), + mMutex("nsIOService::mMutex"), + mTotalRequests(0), + mCacheWon(0), + mNetWon(0), + mLastOfflineStateChange(PR_IntervalNow()), + mLastConnectivityChange(PR_IntervalNow()), + mLastNetworkLinkChange(PR_IntervalNow()), + mNetTearingDownStarted(0), + mSocketProcess(nullptr) {} + +static const char* gCallbackPrefs[] = { + PORT_PREF_PREFIX, + MANAGE_OFFLINE_STATUS_PREF, + NECKO_BUFFER_CACHE_COUNT_PREF, + NECKO_BUFFER_CACHE_SIZE_PREF, + NETWORK_CAPTIVE_PORTAL_PREF, + nullptr, +}; + +static const char* gCallbackPrefsForSocketProcess[] = { + WEBRTC_PREF_PREFIX, + NETWORK_DNS_PREF, + "network.ssl_tokens_cache_enabled", + "network.send_ODA_to_content_directly", + "network.trr.", + "doh-rollout.", + "network.dns.disableIPv6", + "network.dns.skipTRR-when-parental-control-enabled", + "network.offline-mirrors-connectivity", + nullptr, +}; + +static const char* gCallbackSecurityPrefs[] = { + // Note the prefs listed below should be in sync with the code in + // HandleTLSPrefChange(). + "security.tls.version.min", + "security.tls.version.max", + "security.tls.version.enable-deprecated", + "security.tls.hello_downgrade_check", + "security.ssl.require_safe_negotiation", + "security.ssl.enable_false_start", + "security.ssl.enable_alpn", + "security.tls.enable_0rtt_data", + "security.ssl.disable_session_identifiers", + "security.tls.enable_post_handshake_auth", + "security.tls.enable_delegated_credentials", + // Note the prefs listed below should be in sync with the code in + // SetValidationOptionsCommon(). + "security.ssl.enable_ocsp_stapling", + "security.ssl.enable_ocsp_must_staple", + "security.pki.certificate_transparency.mode", + "security.cert_pinning.enforcement_level", + "security.pki.name_matching_mode", + nullptr, +}; + +nsresult nsIOService::Init() { + // XXX hack until xpidl supports error info directly (bug 13423) + nsCOMPtr<nsIErrorService> errorService = nsErrorService::GetOrCreate(); + MOZ_ALWAYS_TRUE(errorService); + errorService->RegisterErrorStringBundle(NS_ERROR_MODULE_NETWORK, + NECKO_MSGS_URL); + + SSLTokensCache::Init(); + + InitializeCaptivePortalService(); + + // setup our bad port list stuff + for (int i = 0; gBadPortList[i]; i++) + mRestrictedPortList.AppendElement(gBadPortList[i]); + + // Further modifications to the port list come from prefs + Preferences::RegisterPrefixCallbacks(nsIOService::PrefsChanged, + gCallbackPrefs, this); + PrefsChanged(); + + mSocketProcessTopicBlackList.PutEntry( + nsLiteralCString(NS_XPCOM_WILL_SHUTDOWN_OBSERVER_ID)); + mSocketProcessTopicBlackList.PutEntry( + nsLiteralCString(NS_XPCOM_SHUTDOWN_OBSERVER_ID)); + mSocketProcessTopicBlackList.PutEntry("xpcom-shutdown-threads"_ns); + mSocketProcessTopicBlackList.PutEntry("profile-do-change"_ns); + + // Register for profile change notifications + mObserverService = services::GetObserverService(); + AddObserver(this, kProfileChangeNetTeardownTopic, true); + AddObserver(this, kProfileChangeNetRestoreTopic, true); + AddObserver(this, kProfileDoChange, true); + AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, true); + AddObserver(this, NS_NETWORK_LINK_TOPIC, true); + AddObserver(this, NS_NETWORK_ID_CHANGED_TOPIC, true); + AddObserver(this, NS_WIDGET_WAKE_OBSERVER_TOPIC, true); + + // Register observers for sending notifications to nsSocketTransportService + if (XRE_IsParentProcess()) { + AddObserver(this, "profile-initial-state", true); + AddObserver(this, NS_WIDGET_SLEEP_OBSERVER_TOPIC, true); + } + + if (IsSocketProcessChild()) { + Preferences::RegisterCallbacks(nsIOService::OnTLSPrefChange, + gCallbackSecurityPrefs, this); + } + + gIOService = this; + + InitializeNetworkLinkService(); + InitializeProtocolProxyService(); + + SetOffline(false); + + return NS_OK; +} + +NS_IMETHODIMP +nsIOService::AddObserver(nsIObserver* aObserver, const char* aTopic, + bool aOwnsWeak) { + if (!mObserverService) { + return NS_ERROR_FAILURE; + } + + // Register for the origional observer. + nsresult rv = mObserverService->AddObserver(aObserver, aTopic, aOwnsWeak); + if (NS_FAILED(rv)) { + return rv; + } + + if (!XRE_IsParentProcess()) { + return NS_OK; + } + + if (!UseSocketProcess()) { + return NS_OK; + } + + nsAutoCString topic(aTopic); + if (mSocketProcessTopicBlackList.Contains(topic)) { + return NS_ERROR_FAILURE; + } + + // Avoid registering duplicate topics. + if (mObserverTopicForSocketProcess.Contains(topic)) { + return NS_ERROR_FAILURE; + } + + mObserverTopicForSocketProcess.PutEntry(topic); + + // This happens when AddObserver() is called by nsIOService::Init(). We don't + // want to add nsIOService again. + if (SameCOMIdentity(aObserver, static_cast<nsIObserver*>(this))) { + return NS_OK; + } + + return mObserverService->AddObserver(this, aTopic, true); +} + +NS_IMETHODIMP +nsIOService::RemoveObserver(nsIObserver* aObserver, const char* aTopic) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsIOService::EnumerateObservers(const char* aTopic, + nsISimpleEnumerator** anEnumerator) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP nsIOService::NotifyObservers(nsISupports* aSubject, + const char* aTopic, + const char16_t* aSomeData) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +nsIOService::~nsIOService() { + if (gIOService) { + MOZ_ASSERT(gIOService == this); + gIOService = nullptr; + } +} + +// static +void nsIOService::OnTLSPrefChange(const char* aPref, void* aSelf) { + MOZ_ASSERT(IsSocketProcessChild()); + + if (!EnsureNSSInitializedChromeOrContent()) { + LOG(("NSS not initialized.")); + return; + } + + nsAutoCString pref(aPref); + // The preferences listed in gCallbackSecurityPrefs need to be in sync with + // the code in HandleTLSPrefChange() and SetValidationOptionsCommon(). + if (HandleTLSPrefChange(pref)) { + LOG(("HandleTLSPrefChange done")); + } else if (pref.EqualsLiteral("security.ssl.enable_ocsp_stapling") || + pref.EqualsLiteral("security.ssl.enable_ocsp_must_staple") || + pref.EqualsLiteral("security.pki.certificate_transparency.mode") || + pref.EqualsLiteral("security.cert_pinning.enforcement_level") || + pref.EqualsLiteral("security.pki.name_matching_mode")) { + SetValidationOptionsCommon(); + } +} + +nsresult nsIOService::InitializeCaptivePortalService() { + if (XRE_GetProcessType() != GeckoProcessType_Default) { + // We only initalize a captive portal service in the main process + return NS_OK; + } + + mCaptivePortalService = do_GetService(NS_CAPTIVEPORTAL_CID); + if (mCaptivePortalService) { + return static_cast<CaptivePortalService*>(mCaptivePortalService.get()) + ->Initialize(); + } + + // Instantiate and initialize the service + RefPtr<NetworkConnectivityService> ncs = + NetworkConnectivityService::GetSingleton(); + + return NS_OK; +} + +nsresult nsIOService::InitializeSocketTransportService() { + nsresult rv = NS_OK; + + if (!mSocketTransportService) { + mSocketTransportService = + do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv); + if (NS_FAILED(rv)) { + NS_WARNING("failed to get socket transport service"); + } + } + + if (mSocketTransportService) { + rv = mSocketTransportService->Init(); + NS_ASSERTION(NS_SUCCEEDED(rv), "socket transport service init failed"); + mSocketTransportService->SetOffline(false); + } + + return rv; +} + +nsresult nsIOService::InitializeNetworkLinkService() { + nsresult rv = NS_OK; + + if (mNetworkLinkServiceInitialized) return rv; + + if (!NS_IsMainThread()) { + NS_WARNING("Network link service should be created on main thread"); + return NS_ERROR_FAILURE; + } + + // go into managed mode if we can, and chrome process + if (!XRE_IsParentProcess()) { + return NS_ERROR_NOT_AVAILABLE; + } + + mNetworkLinkService = do_GetService(NS_NETWORK_LINK_SERVICE_CONTRACTID, &rv); + + if (mNetworkLinkService) { + mNetworkLinkServiceInitialized = true; + } + + // After initializing the networkLinkService, query the connectivity state + OnNetworkLinkEvent(NS_NETWORK_LINK_DATA_UNKNOWN); + + return rv; +} + +nsresult nsIOService::InitializeProtocolProxyService() { + nsresult rv = NS_OK; + + if (XRE_IsParentProcess()) { + // for early-initialization + Unused << do_GetService(NS_PROTOCOLPROXYSERVICE_CONTRACTID, &rv); + } + + return rv; +} + +already_AddRefed<nsIOService> nsIOService::GetInstance() { + if (!gIOService) { + RefPtr<nsIOService> ios = new nsIOService(); + if (NS_SUCCEEDED(ios->Init())) { + MOZ_ASSERT(gIOService == ios.get()); + return ios.forget(); + } + } + return do_AddRef(gIOService); +} + +class SocketProcessListenerProxy : public SocketProcessHost::Listener { + public: + SocketProcessListenerProxy() = default; + void OnProcessLaunchComplete(SocketProcessHost* aHost, bool aSucceeded) { + if (!gIOService) { + return; + } + + gIOService->OnProcessLaunchComplete(aHost, aSucceeded); + } + + void OnProcessUnexpectedShutdown(SocketProcessHost* aHost) { + if (!gIOService) { + return; + } + + gIOService->OnProcessUnexpectedShutdown(aHost); + } +}; + +nsresult nsIOService::LaunchSocketProcess() { + MOZ_ASSERT(NS_IsMainThread()); + + if (XRE_GetProcessType() != GeckoProcessType_Default) { + return NS_OK; + } + + if (mShutdown) { + return NS_OK; + } + + if (mSocketProcess) { + return NS_OK; + } + + if (PR_GetEnv("MOZ_DISABLE_SOCKET_PROCESS")) { + LOG(("nsIOService skipping LaunchSocketProcess because of the env")); + return NS_OK; + } + + if (!Preferences::GetBool("network.process.enabled", true)) { + LOG(("nsIOService skipping LaunchSocketProcess because of the pref")); + return NS_OK; + } + + Preferences::RegisterPrefixCallbacks( + nsIOService::NotifySocketProcessPrefsChanged, + gCallbackPrefsForSocketProcess, this); + + // The subprocess is launched asynchronously, so we wait for a callback to + // acquire the IPDL actor. + mSocketProcess = new SocketProcessHost(new SocketProcessListenerProxy()); + LOG(("nsIOService::LaunchSocketProcess")); + if (!mSocketProcess->Launch()) { + NS_WARNING("Failed to launch socket process!!"); + DestroySocketProcess(); + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +void nsIOService::DestroySocketProcess() { + LOG(("nsIOService::DestroySocketProcess")); + MOZ_ASSERT(NS_IsMainThread()); + + if (XRE_GetProcessType() != GeckoProcessType_Default || !mSocketProcess) { + return; + } + + Preferences::UnregisterPrefixCallbacks( + nsIOService::NotifySocketProcessPrefsChanged, + gCallbackPrefsForSocketProcess, this); + + mSocketProcess->Shutdown(); + mSocketProcess = nullptr; +} + +bool nsIOService::SocketProcessReady() { + return mSocketProcess && mSocketProcess->IsConnected(); +} + +static bool sUseSocketProcess = false; +static bool sUseSocketProcessChecked = false; + +// static +bool nsIOService::UseSocketProcess(bool aCheckAgain) { + if (sUseSocketProcessChecked && !aCheckAgain) { + return sUseSocketProcess; + } + + sUseSocketProcessChecked = true; + sUseSocketProcess = false; + + if (PR_GetEnv("MOZ_DISABLE_SOCKET_PROCESS")) { + return sUseSocketProcess; + } + + if (PR_GetEnv("MOZ_FORCE_USE_SOCKET_PROCESS")) { + sUseSocketProcess = true; + return sUseSocketProcess; + } + + if (StaticPrefs::network_process_enabled()) { + sUseSocketProcess = + StaticPrefs::network_http_network_access_on_socket_process_enabled(); + } + return sUseSocketProcess; +} + +// static +void nsIOService::NotifySocketProcessPrefsChanged(const char* aName, + void* aSelf) { + static_cast<nsIOService*>(aSelf)->NotifySocketProcessPrefsChanged(aName); +} + +void nsIOService::NotifySocketProcessPrefsChanged(const char* aName) { + MOZ_ASSERT(NS_IsMainThread()); + + if (!XRE_IsParentProcess()) { + return; + } + + if (!StaticPrefs::network_process_enabled()) { + return; + } + + dom::Pref pref(nsCString(aName), /* isLocked */ false, Nothing(), Nothing()); + Preferences::GetPreference(&pref); + auto sendPrefUpdate = [pref]() { + Unused << gIOService->mSocketProcess->GetActor()->SendPreferenceUpdate( + pref); + }; + CallOrWaitForSocketProcess(sendPrefUpdate); +} + +void nsIOService::OnProcessLaunchComplete(SocketProcessHost* aHost, + bool aSucceeded) { + MOZ_ASSERT(NS_IsMainThread()); + + LOG(("nsIOService::OnProcessLaunchComplete aSucceeded=%d\n", aSucceeded)); + + mSocketProcessLaunchComplete = true; + + if (mShutdown || !SocketProcessReady()) { + return; + } + + if (!mPendingEvents.IsEmpty()) { + nsTArray<std::function<void()>> pendingEvents = std::move(mPendingEvents); + for (auto& func : pendingEvents) { + func(); + } + } +} + +void nsIOService::CallOrWaitForSocketProcess( + const std::function<void()>& aFunc) { + MOZ_ASSERT(NS_IsMainThread()); + if (IsSocketProcessLaunchComplete() && SocketProcessReady()) { + aFunc(); + } else { + mPendingEvents.AppendElement(aFunc); // infallible + LaunchSocketProcess(); + } +} + +int32_t nsIOService::SocketProcessPid() { + if (!mSocketProcess) { + return 0; + } + if (SocketProcessParent* actor = mSocketProcess->GetActor()) { + return (int32_t)actor->OtherPid(); + } + return 0; +} + +bool nsIOService::IsSocketProcessLaunchComplete() { + MOZ_ASSERT(NS_IsMainThread()); + return mSocketProcessLaunchComplete; +} + +void nsIOService::OnProcessUnexpectedShutdown(SocketProcessHost* aHost) { + MOZ_ASSERT(NS_IsMainThread()); + + LOG(("nsIOService::OnProcessUnexpectedShutdown\n")); + DestroySocketProcess(); +} + +RefPtr<MemoryReportingProcess> nsIOService::GetSocketProcessMemoryReporter() { + // Check the prefs here again, since we don't want to create + // SocketProcessMemoryReporter for some tests. + if (!Preferences::GetBool("network.process.enabled") || + !SocketProcessReady()) { + return nullptr; + } + + return new SocketProcessMemoryReporter(); +} + +NS_IMETHODIMP +nsIOService::SocketProcessTelemetryPing() { + CallOrWaitForSocketProcess([]() { + Unused << gIOService->mSocketProcess->GetActor() + ->SendSocketProcessTelemetryPing(); + }); + return NS_OK; +} + +NS_IMPL_ISUPPORTS(nsIOService, nsIIOService, nsINetUtil, nsISpeculativeConnect, + nsIObserver, nsIIOServiceInternal, nsISupportsWeakReference, + nsIObserverService) + +//////////////////////////////////////////////////////////////////////////////// + +nsresult nsIOService::RecheckCaptivePortal() { + MOZ_ASSERT(NS_IsMainThread(), "Must be called on the main thread"); + if (!mCaptivePortalService) { + return NS_OK; + } + nsCOMPtr<nsIRunnable> task = NewRunnableMethod( + "nsIOService::RecheckCaptivePortal", mCaptivePortalService, + &nsICaptivePortalService::RecheckCaptivePortal); + return NS_DispatchToMainThread(task); +} + +nsresult nsIOService::RecheckCaptivePortalIfLocalRedirect(nsIChannel* newChan) { + nsresult rv; + + if (!mCaptivePortalService) { + return NS_OK; + } + + nsCOMPtr<nsIURI> uri; + rv = newChan->GetURI(getter_AddRefs(uri)); + if (NS_FAILED(rv)) { + return rv; + } + + nsCString host; + rv = uri->GetHost(host); + if (NS_FAILED(rv)) { + return rv; + } + + PRNetAddr prAddr; + if (PR_StringToNetAddr(host.BeginReading(), &prAddr) != PR_SUCCESS) { + // The redirect wasn't to an IP literal, so there's probably no need + // to trigger the captive portal detection right now. It can wait. + return NS_OK; + } + + NetAddr netAddr(&prAddr); + if (netAddr.IsIPAddrLocal()) { + // Redirects to local IP addresses are probably captive portals + RecheckCaptivePortal(); + } + + return NS_OK; +} + +nsresult nsIOService::AsyncOnChannelRedirect( + nsIChannel* oldChan, nsIChannel* newChan, uint32_t flags, + nsAsyncRedirectVerifyHelper* helper) { + // If a redirect to a local network address occurs, then chances are we + // are in a captive portal, so we trigger a recheck. + RecheckCaptivePortalIfLocalRedirect(newChan); + + // This is silly. I wish there was a simpler way to get at the global + // reference of the contentSecurityManager. But it lives in the XPCOM + // service registry. + nsCOMPtr<nsIChannelEventSink> sink = + do_GetService(NS_CONTENTSECURITYMANAGER_CONTRACTID); + if (sink) { + nsresult rv = + helper->DelegateOnChannelRedirect(sink, oldChan, newChan, flags); + if (NS_FAILED(rv)) return rv; + } + + // Finally, our category + nsCOMArray<nsIChannelEventSink> entries; + mChannelEventSinks.GetEntries(entries); + int32_t len = entries.Count(); + for (int32_t i = 0; i < len; ++i) { + nsresult rv = + helper->DelegateOnChannelRedirect(entries[i], oldChan, newChan, flags); + if (NS_FAILED(rv)) return rv; + } + + nsCOMPtr<nsIHttpChannel> httpChan(do_QueryInterface(oldChan)); + + // Collect the redirection from HTTP(S) only. + if (httpChan) { + MOZ_ASSERT(NS_IsMainThread()); + 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() + ? Telemetry::LABELS_NETWORK_HTTP_REDIRECT_TO_SCHEME::topLevel + : Telemetry::LABELS_NETWORK_HTTP_REDIRECT_TO_SCHEME::subresource); + } + + return NS_OK; +} + +nsresult nsIOService::CacheProtocolHandler(const char* scheme, + nsIProtocolHandler* handler) { + MOZ_ASSERT(NS_IsMainThread()); + + for (unsigned int i = 0; i < NS_N(gScheme); i++) { + if (!nsCRT::strcasecmp(scheme, gScheme[i])) { + nsresult rv; + NS_ASSERTION(!mWeakHandler[i], "Protocol handler already cached"); + // Make sure the handler supports weak references. + nsCOMPtr<nsISupportsWeakReference> factoryPtr = + do_QueryInterface(handler, &rv); + if (!factoryPtr) { + // Don't cache handlers that don't support weak reference as + // there is real danger of a circular reference. +#ifdef DEBUG_dp + printf( + "DEBUG: %s protcol handler doesn't support weak ref. Not cached.\n", + scheme); +#endif /* DEBUG_dp */ + return NS_ERROR_FAILURE; + } + mWeakHandler[i] = do_GetWeakReference(handler); + return NS_OK; + } + } + return NS_ERROR_FAILURE; +} + +nsresult nsIOService::GetCachedProtocolHandler(const char* scheme, + nsIProtocolHandler** result, + uint32_t start, uint32_t end) { + MOZ_ASSERT(NS_IsMainThread()); + + uint32_t len = end - start - 1; + for (unsigned int i = 0; i < NS_N(gScheme); i++) { + if (!mWeakHandler[i]) continue; + + // handle unterminated strings + // start is inclusive, end is exclusive, len = end - start - 1 + if (end ? (!nsCRT::strncasecmp(scheme + start, gScheme[i], len) && + gScheme[i][len] == '\0') + : (!nsCRT::strcasecmp(scheme, gScheme[i]))) { + return CallQueryReferent(mWeakHandler[i].get(), result); + } + } + return NS_ERROR_FAILURE; +} + +static bool UsesExternalProtocolHandler(const char* aScheme) { + if ("file"_ns.Equals(aScheme) || "chrome"_ns.Equals(aScheme) || + "resource"_ns.Equals(aScheme)) { + // Don't allow file:, chrome: or resource: URIs to be handled with + // nsExternalProtocolHandler, since internally we rely on being able to + // use and read from these URIs. + return false; + } + + // When ftp protocol is disabled, return true if external protocol handler was + // not explicitly disabled by the prererence. + if ("ftp"_ns.Equals(aScheme) && + !Preferences::GetBool("network.ftp.enabled", true) && + Preferences::GetBool("network.protocol-handler.external.ftp", true)) { + return true; + } + + for (const auto& forcedExternalScheme : gForcedExternalSchemes) { + if (!nsCRT::strcasecmp(forcedExternalScheme, aScheme)) { + return true; + } + } + + nsAutoCString pref("network.protocol-handler.external."); + pref += aScheme; + + return Preferences::GetBool(pref.get(), false); +} + +NS_IMETHODIMP +nsIOService::GetProtocolHandler(const char* scheme, + nsIProtocolHandler** result) { + nsresult rv; + + NS_ENSURE_ARG_POINTER(scheme); + // XXX we may want to speed this up by introducing our own protocol + // scheme -> protocol handler mapping, avoiding the string manipulation + // and service manager stuff + + rv = GetCachedProtocolHandler(scheme, result); + if (NS_SUCCEEDED(rv)) return rv; + + if (scheme[0] != '\0' && !UsesExternalProtocolHandler(scheme)) { + nsAutoCString contractID(NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX); + contractID += scheme; + ToLowerCase(contractID); + + rv = CallGetService(contractID.get(), result); + if (NS_SUCCEEDED(rv)) { + CacheProtocolHandler(scheme, *result); + return rv; + } + +#ifdef MOZ_WIDGET_GTK + // check to see whether GVFS can handle this URI scheme. otherwise, we + // failover to using the default protocol handler. + + RefPtr<nsGIOProtocolHandler> gioHandler = + nsGIOProtocolHandler::GetSingleton(); + if (gioHandler->IsSupportedProtocol(nsCString(scheme))) { + gioHandler.forget(result); + return NS_OK; + } +#endif + } + + // Okay we don't have a protocol handler to handle this url type, so use + // the default protocol handler. This will cause urls to get dispatched + // out to the OS ('cause we can't do anything with them) when we try to + // read from a channel created by the default protocol handler. + + rv = CallGetService(NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX "default", result); + if (NS_FAILED(rv)) return NS_ERROR_UNKNOWN_PROTOCOL; + + return rv; +} + +NS_IMETHODIMP +nsIOService::ExtractScheme(const nsACString& inURI, nsACString& scheme) { + return net_ExtractURLScheme(inURI, scheme); +} + +NS_IMETHODIMP +nsIOService::HostnameIsLocalIPAddress(nsIURI* aURI, bool* aResult) { + NS_ENSURE_ARG_POINTER(aURI); + + nsCOMPtr<nsIURI> innerURI = NS_GetInnermostURI(aURI); + NS_ENSURE_ARG_POINTER(innerURI); + + nsAutoCString host; + nsresult rv = innerURI->GetAsciiHost(host); + if (NS_FAILED(rv)) { + return rv; + } + + *aResult = false; + + PRNetAddr addr; + PRStatus result = PR_StringToNetAddr(host.get(), &addr); + if (result == PR_SUCCESS) { + NetAddr netAddr(&addr); + if (netAddr.IsIPAddrLocal()) { + *aResult = true; + } + } + + return NS_OK; +} + +NS_IMETHODIMP +nsIOService::HostnameIsSharedIPAddress(nsIURI* aURI, bool* aResult) { + NS_ENSURE_ARG_POINTER(aURI); + + nsCOMPtr<nsIURI> innerURI = NS_GetInnermostURI(aURI); + NS_ENSURE_ARG_POINTER(innerURI); + + nsAutoCString host; + nsresult rv = innerURI->GetAsciiHost(host); + if (NS_FAILED(rv)) { + return rv; + } + + *aResult = false; + + PRNetAddr addr; + PRStatus result = PR_StringToNetAddr(host.get(), &addr); + if (result == PR_SUCCESS) { + NetAddr netAddr(&addr); + if (netAddr.IsIPAddrShared()) { + *aResult = true; + } + } + + return NS_OK; +} + +NS_IMETHODIMP +nsIOService::GetProtocolFlags(const char* scheme, uint32_t* flags) { + nsCOMPtr<nsIProtocolHandler> handler; + nsresult rv = GetProtocolHandler(scheme, getter_AddRefs(handler)); + if (NS_FAILED(rv)) return rv; + + // We can't call DoGetProtocolFlags here because we don't have a URI. This + // API is used by (and only used by) extensions, which is why it's still + // around. Calling this on a scheme with dynamic flags will throw. + rv = handler->GetProtocolFlags(flags); +#if !IS_ORIGIN_IS_FULL_SPEC_DEFINED + MOZ_RELEASE_ASSERT(!(*flags & nsIProtocolHandler::ORIGIN_IS_FULL_SPEC), + "ORIGIN_IS_FULL_SPEC is unsupported but used"); +#endif + return rv; +} + +class AutoIncrement { + public: + explicit AutoIncrement(uint32_t* var) : mVar(var) { ++*var; } + ~AutoIncrement() { --*mVar; } + + private: + uint32_t* mVar; +}; + +nsresult nsIOService::NewURI(const nsACString& aSpec, const char* aCharset, + nsIURI* aBaseURI, nsIURI** result) { + return NS_NewURI(result, aSpec, aCharset, aBaseURI); +} + +NS_IMETHODIMP +nsIOService::NewFileURI(nsIFile* file, nsIURI** result) { + nsresult rv; + NS_ENSURE_ARG_POINTER(file); + + nsCOMPtr<nsIProtocolHandler> handler; + + rv = GetProtocolHandler("file", getter_AddRefs(handler)); + if (NS_FAILED(rv)) return rv; + + nsCOMPtr<nsIFileProtocolHandler> fileHandler(do_QueryInterface(handler, &rv)); + if (NS_FAILED(rv)) return rv; + + return fileHandler->NewFileURI(file, result); +} + +// static +already_AddRefed<nsIURI> nsIOService::CreateExposableURI(nsIURI* aURI) { + MOZ_ASSERT(aURI, "Must have a URI"); + nsCOMPtr<nsIURI> uri = aURI; + + nsAutoCString userPass; + uri->GetUserPass(userPass); + if (!userPass.IsEmpty()) { + DebugOnly<nsresult> rv = NS_MutateURI(uri).SetUserPass(""_ns).Finalize(uri); + MOZ_ASSERT(NS_SUCCEEDED(rv) && uri, "Mutating URI should never fail"); + } + return uri.forget(); +} + +NS_IMETHODIMP +nsIOService::CreateExposableURI(nsIURI* aURI, nsIURI** _result) { + NS_ENSURE_ARG_POINTER(aURI); + NS_ENSURE_ARG_POINTER(_result); + nsCOMPtr<nsIURI> exposableURI = CreateExposableURI(aURI); + exposableURI.forget(_result); + return NS_OK; +} + +NS_IMETHODIMP +nsIOService::NewChannelFromURI(nsIURI* aURI, nsINode* aLoadingNode, + nsIPrincipal* aLoadingPrincipal, + nsIPrincipal* aTriggeringPrincipal, + uint32_t aSecurityFlags, + nsContentPolicyType aContentPolicyType, + nsIChannel** result) { + return NewChannelFromURIWithProxyFlags(aURI, + nullptr, // aProxyURI + 0, // aProxyFlags + aLoadingNode, aLoadingPrincipal, + aTriggeringPrincipal, aSecurityFlags, + aContentPolicyType, result); +} +nsresult nsIOService::NewChannelFromURIWithClientAndController( + nsIURI* aURI, nsINode* aLoadingNode, nsIPrincipal* aLoadingPrincipal, + nsIPrincipal* aTriggeringPrincipal, + const Maybe<ClientInfo>& aLoadingClientInfo, + const Maybe<ServiceWorkerDescriptor>& aController, uint32_t aSecurityFlags, + nsContentPolicyType aContentPolicyType, uint32_t aSandboxFlags, + nsIChannel** aResult) { + return NewChannelFromURIWithProxyFlagsInternal( + aURI, + nullptr, // aProxyURI + 0, // aProxyFlags + aLoadingNode, aLoadingPrincipal, aTriggeringPrincipal, aLoadingClientInfo, + aController, aSecurityFlags, aContentPolicyType, aSandboxFlags, aResult); +} + +NS_IMETHODIMP +nsIOService::NewChannelFromURIWithLoadInfo(nsIURI* aURI, nsILoadInfo* aLoadInfo, + nsIChannel** result) { + return NewChannelFromURIWithProxyFlagsInternal(aURI, + nullptr, // aProxyURI + 0, // aProxyFlags + aLoadInfo, result); +} + +nsresult nsIOService::NewChannelFromURIWithProxyFlagsInternal( + nsIURI* aURI, nsIURI* aProxyURI, uint32_t aProxyFlags, + nsINode* aLoadingNode, nsIPrincipal* aLoadingPrincipal, + nsIPrincipal* aTriggeringPrincipal, + const Maybe<ClientInfo>& aLoadingClientInfo, + const Maybe<ServiceWorkerDescriptor>& aController, uint32_t aSecurityFlags, + nsContentPolicyType aContentPolicyType, uint32_t aSandboxFlags, + nsIChannel** result) { + nsCOMPtr<nsILoadInfo> loadInfo = new LoadInfo( + aLoadingPrincipal, aTriggeringPrincipal, aLoadingNode, aSecurityFlags, + aContentPolicyType, aLoadingClientInfo, aController, aSandboxFlags); + return NewChannelFromURIWithProxyFlagsInternal(aURI, aProxyURI, aProxyFlags, + loadInfo, result); +} + +nsresult nsIOService::NewChannelFromURIWithProxyFlagsInternal( + nsIURI* aURI, nsIURI* aProxyURI, uint32_t aProxyFlags, + nsILoadInfo* aLoadInfo, nsIChannel** result) { + nsresult rv; + NS_ENSURE_ARG_POINTER(aURI); + // all channel creations must provide a valid loadinfo + MOZ_ASSERT(aLoadInfo, "can not create channel without aLoadInfo"); + NS_ENSURE_ARG_POINTER(aLoadInfo); + + nsAutoCString scheme; + rv = aURI->GetScheme(scheme); + if (NS_FAILED(rv)) return rv; + + nsCOMPtr<nsIProtocolHandler> handler; + rv = GetProtocolHandler(scheme.get(), getter_AddRefs(handler)); + if (NS_FAILED(rv)) return rv; + + uint32_t protoFlags; + rv = handler->DoGetProtocolFlags(aURI, &protoFlags); + if (NS_FAILED(rv)) return rv; + + nsCOMPtr<nsIChannel> channel; + nsCOMPtr<nsIProxiedProtocolHandler> pph = do_QueryInterface(handler); + if (pph) { + rv = pph->NewProxiedChannel(aURI, nullptr, aProxyFlags, aProxyURI, + aLoadInfo, getter_AddRefs(channel)); + } else { + rv = handler->NewChannel(aURI, aLoadInfo, getter_AddRefs(channel)); + } + if (NS_FAILED(rv)) return rv; + + // Make sure that all the individual protocolhandlers attach a loadInfo. + nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo(); + if (aLoadInfo != loadInfo) { + MOZ_ASSERT(false, "newly created channel must have a loadinfo attached"); + return NS_ERROR_UNEXPECTED; + } + + // If we're sandboxed, make sure to clear any owner the channel + // might already have. + if (loadInfo->GetLoadingSandboxed()) { + channel->SetOwner(nullptr); + } + + // Some extensions override the http protocol handler and provide their own + // implementation. The channels returned from that implementation doesn't + // seem to always implement the nsIUploadChannel2 interface, presumably + // because it's a new interface. + // Eventually we should remove this and simply require that http channels + // implement the new interface. + // See bug 529041 + if (!gHasWarnedUploadChannel2 && scheme.EqualsLiteral("http")) { + nsCOMPtr<nsIUploadChannel2> uploadChannel2 = do_QueryInterface(channel); + if (!uploadChannel2) { + nsCOMPtr<nsIConsoleService> consoleService = + do_GetService(NS_CONSOLESERVICE_CONTRACTID); + if (consoleService) { + consoleService->LogStringMessage( + u"Http channel implementation " + "doesn't support nsIUploadChannel2. An extension has " + "supplied a non-functional http protocol handler. This will " + "break behavior and in future releases not work at all."); + } + gHasWarnedUploadChannel2 = true; + } + } + + channel.forget(result); + return NS_OK; +} + +NS_IMETHODIMP +nsIOService::NewChannelFromURIWithProxyFlags( + nsIURI* aURI, nsIURI* aProxyURI, uint32_t aProxyFlags, + nsINode* aLoadingNode, nsIPrincipal* aLoadingPrincipal, + nsIPrincipal* aTriggeringPrincipal, uint32_t aSecurityFlags, + nsContentPolicyType aContentPolicyType, nsIChannel** result) { + return NewChannelFromURIWithProxyFlagsInternal( + aURI, aProxyURI, aProxyFlags, aLoadingNode, aLoadingPrincipal, + aTriggeringPrincipal, Maybe<ClientInfo>(), + Maybe<ServiceWorkerDescriptor>(), aSecurityFlags, aContentPolicyType, 0, + result); +} + +NS_IMETHODIMP +nsIOService::NewChannel(const nsACString& aSpec, const char* aCharset, + nsIURI* aBaseURI, nsINode* aLoadingNode, + nsIPrincipal* aLoadingPrincipal, + nsIPrincipal* aTriggeringPrincipal, + uint32_t aSecurityFlags, + nsContentPolicyType aContentPolicyType, + nsIChannel** result) { + nsresult rv; + nsCOMPtr<nsIURI> uri; + rv = NewURI(aSpec, aCharset, aBaseURI, getter_AddRefs(uri)); + if (NS_FAILED(rv)) return rv; + + return NewChannelFromURI(uri, aLoadingNode, aLoadingPrincipal, + aTriggeringPrincipal, aSecurityFlags, + aContentPolicyType, result); +} + +bool nsIOService::IsLinkUp() { + InitializeNetworkLinkService(); + + if (!mNetworkLinkService) { + // We cannot decide, assume the link is up + return true; + } + + bool isLinkUp; + nsresult rv; + rv = mNetworkLinkService->GetIsLinkUp(&isLinkUp); + if (NS_FAILED(rv)) { + return true; + } + + return isLinkUp; +} + +NS_IMETHODIMP +nsIOService::GetOffline(bool* offline) { + if (StaticPrefs::network_offline_mirrors_connectivity()) { + *offline = mOffline || !mConnectivity; + } else { + *offline = mOffline; + } + return NS_OK; +} + +NS_IMETHODIMP +nsIOService::SetOffline(bool offline) { + LOG(("nsIOService::SetOffline offline=%d\n", offline)); + // When someone wants to go online (!offline) after we got XPCOM shutdown + // throw ERROR_NOT_AVAILABLE to prevent return to online state. + if ((mShutdown || mOfflineForProfileChange) && !offline) + return NS_ERROR_NOT_AVAILABLE; + + // SetOffline() may re-enter while it's shutting down services. + // If that happens, save the most recent value and it will be + // processed when the first SetOffline() call is done bringing + // down the service. + mSetOfflineValue = offline; + if (mSettingOffline) { + return NS_OK; + } + + mSettingOffline = true; + + nsCOMPtr<nsIObserverService> observerService = services::GetObserverService(); + + NS_ASSERTION(observerService, "The observer service should not be null"); + + if (XRE_IsParentProcess()) { + if (observerService) { + (void)observerService->NotifyObservers(nullptr, + NS_IPC_IOSERVICE_SET_OFFLINE_TOPIC, + offline ? u"true" : u"false"); + } + if (SocketProcessReady()) { + Unused << mSocketProcess->GetActor()->SendSetOffline(offline); + } + } + + nsIIOService* subject = static_cast<nsIIOService*>(this); + while (mSetOfflineValue != mOffline) { + offline = mSetOfflineValue; + + if (offline && !mOffline) { + mOffline = true; // indicate we're trying to shutdown + + // don't care if notifications fail + if (observerService) + observerService->NotifyObservers(subject, + NS_IOSERVICE_GOING_OFFLINE_TOPIC, + u"" NS_IOSERVICE_OFFLINE); + + if (mSocketTransportService) mSocketTransportService->SetOffline(true); + + mLastOfflineStateChange = PR_IntervalNow(); + if (observerService) + observerService->NotifyObservers(subject, + NS_IOSERVICE_OFFLINE_STATUS_TOPIC, + u"" NS_IOSERVICE_OFFLINE); + } else if (!offline && mOffline) { + // go online + InitializeSocketTransportService(); + mOffline = false; // indicate success only AFTER we've + // brought up the services + + mLastOfflineStateChange = PR_IntervalNow(); + // don't care if notification fails + // Only send the ONLINE notification if there is connectivity + if (observerService && mConnectivity) { + observerService->NotifyObservers(subject, + NS_IOSERVICE_OFFLINE_STATUS_TOPIC, + (u"" NS_IOSERVICE_ONLINE)); + } + } + } + + // Don't notify here, as the above notifications (if used) suffice. + if ((mShutdown || mOfflineForProfileChange) && mOffline) { + if (mSocketTransportService) { + DebugOnly<nsresult> rv = mSocketTransportService->Shutdown(mShutdown); + NS_ASSERTION(NS_SUCCEEDED(rv), + "socket transport service shutdown failed"); + } + } + + mSettingOffline = false; + + return NS_OK; +} + +NS_IMETHODIMP +nsIOService::GetConnectivity(bool* aConnectivity) { + *aConnectivity = mConnectivity; + return NS_OK; +} + +NS_IMETHODIMP +nsIOService::SetConnectivity(bool aConnectivity) { + LOG(("nsIOService::SetConnectivity aConnectivity=%d\n", aConnectivity)); + // This should only be called from ContentChild to pass the connectivity + // value from the chrome process to the content process. + if (XRE_IsParentProcess()) { + return NS_ERROR_NOT_AVAILABLE; + } + return SetConnectivityInternal(aConnectivity); +} + +nsresult nsIOService::SetConnectivityInternal(bool aConnectivity) { + LOG(("nsIOService::SetConnectivityInternal aConnectivity=%d\n", + aConnectivity)); + if (mConnectivity == aConnectivity) { + // Nothing to do here. + return NS_OK; + } + mConnectivity = aConnectivity; + + // This is used for PR_Connect PR_Close telemetry so it is important that + // we have statistic about network change event even if we are offline. + mLastConnectivityChange = PR_IntervalNow(); + + if (mCaptivePortalService) { + if (aConnectivity && gCaptivePortalEnabled) { + // This will also trigger a captive portal check for the new network + static_cast<CaptivePortalService*>(mCaptivePortalService.get())->Start(); + } else { + static_cast<CaptivePortalService*>(mCaptivePortalService.get())->Stop(); + } + } + + nsCOMPtr<nsIObserverService> observerService = services::GetObserverService(); + if (!observerService) { + return NS_OK; + } + // This notification sends the connectivity to the child processes + if (XRE_IsParentProcess()) { + observerService->NotifyObservers(nullptr, + NS_IPC_IOSERVICE_SET_CONNECTIVITY_TOPIC, + aConnectivity ? u"true" : u"false"); + if (SocketProcessReady()) { + Unused << mSocketProcess->GetActor()->SendSetConnectivity(aConnectivity); + } + } + + if (mOffline) { + // We don't need to send any notifications if we're offline + return NS_OK; + } + + if (aConnectivity) { + // If we were previously offline due to connectivity=false, + // send the ONLINE notification + observerService->NotifyObservers(static_cast<nsIIOService*>(this), + NS_IOSERVICE_OFFLINE_STATUS_TOPIC, + (u"" NS_IOSERVICE_ONLINE)); + } else { + // If we were previously online and lost connectivity + // send the OFFLINE notification + observerService->NotifyObservers(static_cast<nsIIOService*>(this), + NS_IOSERVICE_GOING_OFFLINE_TOPIC, + u"" NS_IOSERVICE_OFFLINE); + observerService->NotifyObservers(static_cast<nsIIOService*>(this), + NS_IOSERVICE_OFFLINE_STATUS_TOPIC, + u"" NS_IOSERVICE_OFFLINE); + } + return NS_OK; +} + +NS_IMETHODIMP +nsIOService::AllowPort(int32_t inPort, const char* scheme, bool* _retval) { + int32_t port = inPort; + if (port == -1) { + *_retval = true; + return NS_OK; + } + + if (port == 0) { + *_retval = false; + return NS_OK; + } + + nsTArray<int32_t> restrictedPortList; + { + MutexAutoLock lock(mMutex); + restrictedPortList.Assign(mRestrictedPortList); + } + + // first check to see if the port is in our blacklist: + int32_t badPortListCnt = restrictedPortList.Length(); + for (int i = 0; i < badPortListCnt; i++) { + if (port == restrictedPortList[i]) { + *_retval = false; + + // check to see if the protocol wants to override + if (!scheme) return NS_OK; + + // We don't support get protocol handler off main thread. + if (!NS_IsMainThread()) { + return NS_OK; + } + nsCOMPtr<nsIProtocolHandler> handler; + nsresult rv = GetProtocolHandler(scheme, getter_AddRefs(handler)); + if (NS_FAILED(rv)) return rv; + + // let the protocol handler decide + return handler->AllowPort(port, scheme, _retval); + } + } + + *_retval = true; + return NS_OK; +} + +//////////////////////////////////////////////////////////////////////////////// + +// static +void nsIOService::PrefsChanged(const char* pref, void* self) { + static_cast<nsIOService*>(self)->PrefsChanged(pref); +} + +void nsIOService::PrefsChanged(const char* pref) { + // Look for extra ports to block + if (!pref || strcmp(pref, PORT_PREF("banned")) == 0) + ParsePortList(PORT_PREF("banned"), false); + + // ...as well as previous blocks to remove. + if (!pref || strcmp(pref, PORT_PREF("banned.override")) == 0) + ParsePortList(PORT_PREF("banned.override"), true); + + if (!pref || strcmp(pref, MANAGE_OFFLINE_STATUS_PREF) == 0) { + bool manage; + if (mNetworkLinkServiceInitialized && + NS_SUCCEEDED( + Preferences::GetBool(MANAGE_OFFLINE_STATUS_PREF, &manage))) { + LOG(("nsIOService::PrefsChanged ManageOfflineStatus manage=%d\n", + manage)); + SetManageOfflineStatus(manage); + } + } + + if (!pref || strcmp(pref, NECKO_BUFFER_CACHE_COUNT_PREF) == 0) { + int32_t count; + if (NS_SUCCEEDED( + Preferences::GetInt(NECKO_BUFFER_CACHE_COUNT_PREF, &count))) + /* check for bogus values and default if we find such a value */ + if (count > 0) gDefaultSegmentCount = count; + } + + if (!pref || strcmp(pref, NECKO_BUFFER_CACHE_SIZE_PREF) == 0) { + int32_t size; + if (NS_SUCCEEDED(Preferences::GetInt(NECKO_BUFFER_CACHE_SIZE_PREF, &size))) + /* check for bogus values and default if we find such a value + * the upper limit here is arbitrary. having a 1mb segment size + * is pretty crazy. if you remove this, consider adding some + * integer rollover test. + */ + if (size > 0 && size < 1024 * 1024) gDefaultSegmentSize = size; + NS_WARNING_ASSERTION(!(size & (size - 1)), + "network segment size is not a power of 2!"); + } + + if (!pref || strcmp(pref, NETWORK_CAPTIVE_PORTAL_PREF) == 0) { + nsresult rv = Preferences::GetBool(NETWORK_CAPTIVE_PORTAL_PREF, + &gCaptivePortalEnabled); + if (NS_SUCCEEDED(rv) && mCaptivePortalService) { + if (gCaptivePortalEnabled) { + static_cast<CaptivePortalService*>(mCaptivePortalService.get()) + ->Start(); + } else { + static_cast<CaptivePortalService*>(mCaptivePortalService.get())->Stop(); + } + } + } +} + +void nsIOService::ParsePortList(const char* pref, bool remove) { + nsAutoCString portList; + nsTArray<int32_t> restrictedPortList; + { + MutexAutoLock lock(mMutex); + restrictedPortList.Assign(std::move(mRestrictedPortList)); + } + // Get a pref string and chop it up into a list of ports. + Preferences::GetCString(pref, portList); + if (!portList.IsVoid()) { + nsTArray<nsCString> portListArray; + ParseString(portList, ',', portListArray); + uint32_t index; + for (index = 0; index < portListArray.Length(); index++) { + portListArray[index].StripWhitespace(); + int32_t portBegin, portEnd; + + if (PR_sscanf(portListArray[index].get(), "%d-%d", &portBegin, + &portEnd) == 2) { + if ((portBegin < 65536) && (portEnd < 65536)) { + int32_t curPort; + if (remove) { + for (curPort = portBegin; curPort <= portEnd; curPort++) + restrictedPortList.RemoveElement(curPort); + } else { + for (curPort = portBegin; curPort <= portEnd; curPort++) + restrictedPortList.AppendElement(curPort); + } + } + } else { + nsresult aErrorCode; + int32_t port = portListArray[index].ToInteger(&aErrorCode); + if (NS_SUCCEEDED(aErrorCode) && port < 65536) { + if (remove) + restrictedPortList.RemoveElement(port); + else + restrictedPortList.AppendElement(port); + } + } + } + } + + MutexAutoLock lock(mMutex); + mRestrictedPortList.Assign(std::move(restrictedPortList)); +} + +class nsWakeupNotifier : public Runnable { + public: + explicit nsWakeupNotifier(nsIIOServiceInternal* ioService) + : Runnable("net::nsWakeupNotifier"), mIOService(ioService) {} + + NS_IMETHOD Run() override { return mIOService->NotifyWakeup(); } + + private: + virtual ~nsWakeupNotifier() = default; + nsCOMPtr<nsIIOServiceInternal> mIOService; +}; + +NS_IMETHODIMP +nsIOService::NotifyWakeup() { + nsCOMPtr<nsIObserverService> observerService = services::GetObserverService(); + + NS_ASSERTION(observerService, "The observer service should not be null"); + + if (observerService && StaticPrefs::network_notify_changed()) { + (void)observerService->NotifyObservers(nullptr, NS_NETWORK_LINK_TOPIC, + (u"" NS_NETWORK_LINK_DATA_CHANGED)); + } + + RecheckCaptivePortal(); + + return NS_OK; +} + +void nsIOService::SetHttpHandlerAlreadyShutingDown() { + if (!mShutdown && !mOfflineForProfileChange) { + mNetTearingDownStarted = PR_IntervalNow(); + mHttpHandlerAlreadyShutingDown = true; + } +} + +// nsIObserver interface +NS_IMETHODIMP +nsIOService::Observe(nsISupports* subject, const char* topic, + const char16_t* data) { + if (!strcmp(topic, kProfileChangeNetTeardownTopic)) { + if (!mHttpHandlerAlreadyShutingDown) { + mNetTearingDownStarted = PR_IntervalNow(); + } + mHttpHandlerAlreadyShutingDown = false; + if (!mOffline) { + mOfflineForProfileChange = true; + SetOffline(true); + } + } else if (!strcmp(topic, kProfileChangeNetRestoreTopic)) { + if (mOfflineForProfileChange) { + mOfflineForProfileChange = false; + SetOffline(false); + } + } else if (!strcmp(topic, kProfileDoChange)) { + if (data && u"startup"_ns.Equals(data)) { + // Lazy initialization of network link service (see bug 620472) + InitializeNetworkLinkService(); + // Set up the initilization flag regardless the actuall result. + // If we fail here, we will fail always on. + mNetworkLinkServiceInitialized = true; + + // And now reflect the preference setting + PrefsChanged(MANAGE_OFFLINE_STATUS_PREF); + + // Bug 870460 - Read cookie database at an early-as-possible time + // off main thread. Hence, we have more chance to finish db query + // before something calls into the cookie service. + nsCOMPtr<nsISupports> cookieServ = + do_GetService(NS_COOKIESERVICE_CONTRACTID); + } + } else if (!strcmp(topic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) { + // Remember we passed XPCOM shutdown notification to prevent any + // changes of the offline status from now. We must not allow going + // online after this point. + mShutdown = true; + + if (!mHttpHandlerAlreadyShutingDown && !mOfflineForProfileChange) { + mNetTearingDownStarted = PR_IntervalNow(); + } + mHttpHandlerAlreadyShutingDown = false; + + SetOffline(true); + + if (mCaptivePortalService) { + static_cast<CaptivePortalService*>(mCaptivePortalService.get())->Stop(); + mCaptivePortalService = nullptr; + } + + SSLTokensCache::Shutdown(); + + DestroySocketProcess(); + + if (IsSocketProcessChild()) { + Preferences::UnregisterCallbacks(nsIOService::OnTLSPrefChange, + gCallbackSecurityPrefs, this); + NSSShutdownForSocketProcess(); + } + } else if (!strcmp(topic, NS_NETWORK_LINK_TOPIC)) { + OnNetworkLinkEvent(NS_ConvertUTF16toUTF8(data).get()); + } else if (!strcmp(topic, NS_NETWORK_ID_CHANGED_TOPIC)) { + LOG(("nsIOService::OnNetworkLinkEvent Network id changed")); + } else if (!strcmp(topic, NS_WIDGET_WAKE_OBSERVER_TOPIC)) { + // coming back alive from sleep + // this indirection brought to you by: + // https://bugzilla.mozilla.org/show_bug.cgi?id=1152048#c19 + nsCOMPtr<nsIRunnable> wakeupNotifier = new nsWakeupNotifier(this); + NS_DispatchToMainThread(wakeupNotifier); + } + + if (UseSocketProcess() && + mObserverTopicForSocketProcess.Contains(nsDependentCString(topic))) { + nsCString topicStr(topic); + nsString dataStr(data); + auto sendObserver = [topicStr, dataStr]() { + Unused << gIOService->mSocketProcess->GetActor()->SendNotifyObserver( + topicStr, dataStr); + }; + CallOrWaitForSocketProcess(sendObserver); + } + + return NS_OK; +} + +// nsINetUtil interface +NS_IMETHODIMP +nsIOService::ParseRequestContentType(const nsACString& aTypeHeader, + nsACString& aCharset, bool* aHadCharset, + nsACString& aContentType) { + net_ParseRequestContentType(aTypeHeader, aContentType, aCharset, aHadCharset); + return NS_OK; +} + +// nsINetUtil interface +NS_IMETHODIMP +nsIOService::ParseResponseContentType(const nsACString& aTypeHeader, + nsACString& aCharset, bool* aHadCharset, + nsACString& aContentType) { + net_ParseContentType(aTypeHeader, aContentType, aCharset, aHadCharset); + return NS_OK; +} + +NS_IMETHODIMP +nsIOService::ProtocolHasFlags(nsIURI* uri, uint32_t flags, bool* result) { + NS_ENSURE_ARG(uri); + + *result = false; + nsAutoCString scheme; + nsresult rv = uri->GetScheme(scheme); + NS_ENSURE_SUCCESS(rv, rv); + + // Grab the protocol flags from the URI. + uint32_t protocolFlags; + nsCOMPtr<nsIProtocolHandler> handler; + rv = GetProtocolHandler(scheme.get(), getter_AddRefs(handler)); + NS_ENSURE_SUCCESS(rv, rv); + rv = handler->DoGetProtocolFlags(uri, &protocolFlags); + NS_ENSURE_SUCCESS(rv, rv); + + *result = (protocolFlags & flags) == flags; + return NS_OK; +} + +NS_IMETHODIMP +nsIOService::URIChainHasFlags(nsIURI* uri, uint32_t flags, bool* result) { + nsresult rv = ProtocolHasFlags(uri, flags, result); + NS_ENSURE_SUCCESS(rv, rv); + + if (*result) { + return rv; + } + + // Dig deeper into the chain. Note that this is not a do/while loop to + // avoid the extra addref/release on |uri| in the common (non-nested) case. + nsCOMPtr<nsINestedURI> nestedURI = do_QueryInterface(uri); + while (nestedURI) { + nsCOMPtr<nsIURI> innerURI; + rv = nestedURI->GetInnerURI(getter_AddRefs(innerURI)); + NS_ENSURE_SUCCESS(rv, rv); + + rv = ProtocolHasFlags(innerURI, flags, result); + + if (*result) { + return rv; + } + + nestedURI = do_QueryInterface(innerURI); + } + + return rv; +} + +NS_IMETHODIMP +nsIOService::SetManageOfflineStatus(bool aManage) { + LOG(("nsIOService::SetManageOfflineStatus aManage=%d\n", aManage)); + mManageLinkStatus = aManage; + + // When detection is not activated, the default connectivity state is true. + if (!mManageLinkStatus) { + SetConnectivityInternal(true); + return NS_OK; + } + + InitializeNetworkLinkService(); + // If the NetworkLinkService is already initialized, it does not call + // OnNetworkLinkEvent. This is needed, when mManageLinkStatus goes from + // false to true. + OnNetworkLinkEvent(NS_NETWORK_LINK_DATA_UNKNOWN); + return NS_OK; +} + +NS_IMETHODIMP +nsIOService::GetManageOfflineStatus(bool* aManage) { + *aManage = mManageLinkStatus; + return NS_OK; +} + +// input argument 'data' is already UTF8'ed +nsresult nsIOService::OnNetworkLinkEvent(const char* data) { + if (IsNeckoChild() || IsSocketProcessChild()) { + // There is nothing IO service could do on the child process + // with this at the moment. Feel free to add functionality + // here at will, though. + return NS_OK; + } + + if (mShutdown) { + return NS_ERROR_NOT_AVAILABLE; + } + + nsCString dataAsString(data); + for (auto* cp : mozilla::dom::ContentParent::AllProcesses( + mozilla::dom::ContentParent::eLive)) { + PNeckoParent* neckoParent = SingleManagedOrNull(cp->ManagedPNeckoParent()); + if (!neckoParent) { + continue; + } + Unused << neckoParent->SendNetworkChangeNotification(dataAsString); + } + + LOG(("nsIOService::OnNetworkLinkEvent data:%s\n", data)); + if (!mNetworkLinkService) { + return NS_ERROR_FAILURE; + } + + if (!mManageLinkStatus) { + LOG(("nsIOService::OnNetworkLinkEvent mManageLinkStatus=false\n")); + return NS_OK; + } + + bool isUp = true; + if (!strcmp(data, NS_NETWORK_LINK_DATA_CHANGED)) { + mLastNetworkLinkChange = PR_IntervalNow(); + // CHANGED means UP/DOWN didn't change + // but the status of the captive portal may have changed. + RecheckCaptivePortal(); + return NS_OK; + } + if (!strcmp(data, NS_NETWORK_LINK_DATA_DOWN)) { + isUp = false; + } else if (!strcmp(data, NS_NETWORK_LINK_DATA_UP)) { + isUp = true; + } else if (!strcmp(data, NS_NETWORK_LINK_DATA_UNKNOWN)) { + nsresult rv = mNetworkLinkService->GetIsLinkUp(&isUp); + NS_ENSURE_SUCCESS(rv, rv); + } else { + NS_WARNING("Unhandled network event!"); + return NS_OK; + } + + return SetConnectivityInternal(isUp); +} + +NS_IMETHODIMP +nsIOService::EscapeString(const nsACString& aString, uint32_t aEscapeType, + nsACString& aResult) { + NS_ENSURE_ARG_MAX(aEscapeType, 4); + + nsAutoCString stringCopy(aString); + nsCString result; + + if (!NS_Escape(stringCopy, result, (nsEscapeMask)aEscapeType)) + return NS_ERROR_OUT_OF_MEMORY; + + aResult.Assign(result); + + return NS_OK; +} + +NS_IMETHODIMP +nsIOService::EscapeURL(const nsACString& aStr, uint32_t aFlags, + nsACString& aResult) { + aResult.Truncate(); + NS_EscapeURL(aStr.BeginReading(), aStr.Length(), aFlags | esc_AlwaysCopy, + aResult); + return NS_OK; +} + +NS_IMETHODIMP +nsIOService::UnescapeString(const nsACString& aStr, uint32_t aFlags, + nsACString& aResult) { + aResult.Truncate(); + NS_UnescapeURL(aStr.BeginReading(), aStr.Length(), aFlags | esc_AlwaysCopy, + aResult); + return NS_OK; +} + +NS_IMETHODIMP +nsIOService::ExtractCharsetFromContentType(const nsACString& aTypeHeader, + nsACString& aCharset, + int32_t* aCharsetStart, + int32_t* aCharsetEnd, + bool* aHadCharset) { + nsAutoCString ignored; + net_ParseContentType(aTypeHeader, ignored, aCharset, aHadCharset, + aCharsetStart, aCharsetEnd); + if (*aHadCharset && *aCharsetStart == *aCharsetEnd) { + *aHadCharset = false; + } + return NS_OK; +} + +// nsISpeculativeConnect +class IOServiceProxyCallback final : public nsIProtocolProxyCallback { + ~IOServiceProxyCallback() = default; + + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIPROTOCOLPROXYCALLBACK + + IOServiceProxyCallback(nsIInterfaceRequestor* aCallbacks, + nsIOService* aIOService) + : mCallbacks(aCallbacks), mIOService(aIOService) {} + + private: + RefPtr<nsIInterfaceRequestor> mCallbacks; + RefPtr<nsIOService> mIOService; +}; + +NS_IMPL_ISUPPORTS(IOServiceProxyCallback, nsIProtocolProxyCallback) + +NS_IMETHODIMP +IOServiceProxyCallback::OnProxyAvailable(nsICancelable* request, + nsIChannel* channel, nsIProxyInfo* pi, + nsresult status) { + // Checking proxy status for speculative connect + nsAutoCString type; + if (NS_SUCCEEDED(status) && pi && NS_SUCCEEDED(pi->GetType(type)) && + !type.EqualsLiteral("direct")) { + // proxies dont do speculative connect + return NS_OK; + } + + nsCOMPtr<nsIURI> uri; + nsresult rv = channel->GetURI(getter_AddRefs(uri)); + if (NS_FAILED(rv)) { + return NS_OK; + } + + nsAutoCString scheme; + rv = uri->GetScheme(scheme); + if (NS_FAILED(rv)) return NS_OK; + + nsCOMPtr<nsIProtocolHandler> handler; + rv = mIOService->GetProtocolHandler(scheme.get(), getter_AddRefs(handler)); + if (NS_FAILED(rv)) return NS_OK; + + nsCOMPtr<nsISpeculativeConnect> speculativeHandler = + do_QueryInterface(handler); + if (!speculativeHandler) return NS_OK; + + nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo(); + nsCOMPtr<nsIPrincipal> principal = loadInfo->GetLoadingPrincipal(); + + nsLoadFlags loadFlags = 0; + channel->GetLoadFlags(&loadFlags); + if (loadFlags & nsIRequest::LOAD_ANONYMOUS) { + speculativeHandler->SpeculativeAnonymousConnect(uri, principal, mCallbacks); + } else { + speculativeHandler->SpeculativeConnect(uri, principal, mCallbacks); + } + + return NS_OK; +} + +nsresult nsIOService::SpeculativeConnectInternal( + nsIURI* aURI, nsIPrincipal* aPrincipal, nsIInterfaceRequestor* aCallbacks, + bool aAnonymous) { + NS_ENSURE_ARG(aURI); + + if (!aURI->SchemeIs("http") && !aURI->SchemeIs("https")) { + // We don't speculatively connect to non-HTTP[S] URIs. + return NS_OK; + } + + if (IsNeckoChild()) { + gNeckoChild->SendSpeculativeConnect(aURI, aPrincipal, aAnonymous); + return NS_OK; + } + + // Check for proxy information. If there is a proxy configured then a + // speculative connect should not be performed because the potential + // reward is slim with tcp peers closely located to the browser. + nsresult rv; + nsCOMPtr<nsIProtocolProxyService> pps = + do_GetService(NS_PROTOCOLPROXYSERVICE_CONTRACTID, &rv); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIPrincipal> loadingPrincipal = aPrincipal; + + MOZ_ASSERT(aPrincipal, "We expect passing a principal here."); + + if (!aPrincipal) { + return NS_ERROR_INVALID_ARG; + } + + // dummy channel used to create a TCP connection. + // we perform security checks on the *real* channel, responsible + // for any network loads. this real channel just checks the TCP + // pool if there is an available connection created by the + // channel we create underneath - hence it's safe to use + // the systemPrincipal as the loadingPrincipal for this channel. + nsCOMPtr<nsIChannel> channel; + rv = NewChannelFromURI( + aURI, + nullptr, // aLoadingNode, + loadingPrincipal, + nullptr, // aTriggeringPrincipal, + nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL, + nsIContentPolicy::TYPE_SPECULATIVE, getter_AddRefs(channel)); + NS_ENSURE_SUCCESS(rv, rv); + + if (aAnonymous) { + nsLoadFlags loadFlags = 0; + channel->GetLoadFlags(&loadFlags); + loadFlags |= nsIRequest::LOAD_ANONYMOUS; + channel->SetLoadFlags(loadFlags); + } + + nsCOMPtr<nsICancelable> cancelable; + RefPtr<IOServiceProxyCallback> callback = + new IOServiceProxyCallback(aCallbacks, this); + nsCOMPtr<nsIProtocolProxyService2> pps2 = do_QueryInterface(pps); + if (pps2) { + return pps2->AsyncResolve2(channel, 0, callback, nullptr, + getter_AddRefs(cancelable)); + } + return pps->AsyncResolve(channel, 0, callback, nullptr, + getter_AddRefs(cancelable)); +} + +NS_IMETHODIMP +nsIOService::SpeculativeConnect(nsIURI* aURI, nsIPrincipal* aPrincipal, + nsIInterfaceRequestor* aCallbacks) { + return SpeculativeConnectInternal(aURI, aPrincipal, aCallbacks, false); +} + +NS_IMETHODIMP +nsIOService::SpeculativeAnonymousConnect(nsIURI* aURI, nsIPrincipal* aPrincipal, + nsIInterfaceRequestor* aCallbacks) { + return SpeculativeConnectInternal(aURI, aPrincipal, aCallbacks, true); +} + +NS_IMETHODIMP +nsIOService::NotImplemented() { return NS_ERROR_NOT_IMPLEMENTED; } + +NS_IMETHODIMP +nsIOService::GetSocketProcessLaunched(bool* aResult) { + NS_ENSURE_ARG_POINTER(aResult); + + *aResult = SocketProcessReady(); + return NS_OK; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/nsIOService.h b/netwerk/base/nsIOService.h new file mode 100644 index 0000000000..5d5c3a66e3 --- /dev/null +++ b/netwerk/base/nsIOService.h @@ -0,0 +1,274 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef nsIOService_h__ +#define nsIOService_h__ + +#include "nsStringFwd.h" +#include "nsIIOService.h" +#include "nsTArray.h" +#include "nsCOMPtr.h" +#include "nsIObserver.h" +#include "nsIWeakReferenceUtils.h" +#include "nsINetUtil.h" +#include "nsIChannelEventSink.h" +#include "nsCategoryCache.h" +#include "nsISpeculativeConnect.h" +#include "nsDataHashtable.h" +#include "nsWeakReference.h" +#include "mozilla/Atomics.h" +#include "mozilla/Attributes.h" +#include "mozilla/Mutex.h" +#include "prtime.h" +#include "nsICaptivePortalService.h" +#include "nsIObserverService.h" +#include "nsWeakReference.h" + +#define NS_N(x) (sizeof(x) / sizeof(*x)) + +// We don't want to expose this observer topic. +// Intended internal use only for remoting offline/inline events. +// See Bug 552829 +#define NS_IPC_IOSERVICE_SET_OFFLINE_TOPIC "ipc:network:set-offline" +#define NS_IPC_IOSERVICE_SET_CONNECTIVITY_TOPIC "ipc:network:set-connectivity" + +static const char gScheme[][sizeof("moz-safe-about")] = { + "chrome", "file", "http", "https", + "jar", "data", "about", "moz-safe-about", + "resource", "moz-extension", "page-icon", "blob"}; + +static const char gForcedExternalSchemes[][sizeof("moz-nullprincipal")] = { + "place", "fake-favicon-uri", "favicon", "moz-nullprincipal"}; + +class nsINetworkLinkService; +class nsIPrefBranch; +class nsIProtocolProxyService2; +class nsIProxyInfo; +class nsPISocketTransportService; + +namespace mozilla { +class MemoryReportingProcess; +namespace net { +class NeckoChild; +class nsAsyncRedirectVerifyHelper; +class SocketProcessHost; +class SocketProcessMemoryReporter; + +class nsIOService final : public nsIIOService, + public nsIObserver, + public nsINetUtil, + public nsISpeculativeConnect, + public nsSupportsWeakReference, + public nsIIOServiceInternal, + public nsIObserverService { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIIOSERVICE + NS_DECL_NSIOBSERVER + NS_DECL_NSINETUTIL + NS_DECL_NSISPECULATIVECONNECT + NS_DECL_NSIIOSERVICEINTERNAL + NS_DECL_NSIOBSERVERSERVICE + + // Gets the singleton instance of the IO Service, creating it as needed + // Returns nullptr on out of memory or failure to initialize. + static already_AddRefed<nsIOService> GetInstance(); + + nsresult Init(); + nsresult NewURI(const char* aSpec, nsIURI* aBaseURI, nsIURI** result, + nsIProtocolHandler** hdlrResult); + + // Called by channels before a redirect happens. This notifies the global + // redirect observers. + nsresult AsyncOnChannelRedirect(nsIChannel* oldChan, nsIChannel* newChan, + uint32_t flags, + nsAsyncRedirectVerifyHelper* helper); + + bool IsOffline() { return mOffline; } + PRIntervalTime LastOfflineStateChange() { return mLastOfflineStateChange; } + PRIntervalTime LastConnectivityChange() { return mLastConnectivityChange; } + PRIntervalTime LastNetworkLinkChange() { return mLastNetworkLinkChange; } + bool IsNetTearingDown() { + return mShutdown || mOfflineForProfileChange || + mHttpHandlerAlreadyShutingDown; + } + PRIntervalTime NetTearingDownStarted() { return mNetTearingDownStarted; } + + // nsHttpHandler is going to call this function to inform nsIOService that + // network is in process of tearing down. Moving nsHttpConnectionMgr::Shutdown + // to nsIOService caused problems (bug 1242755) so we doing it in this way. As + // soon as nsIOService gets notification that it is shutdown it is going to + // reset mHttpHandlerAlreadyShutingDown. + void SetHttpHandlerAlreadyShutingDown(); + + bool IsLinkUp(); + + // Converts an internal URI (e.g. one that has a username and password in + // it) into one which we can expose to the user, for example on the URL bar. + static already_AddRefed<nsIURI> CreateExposableURI(nsIURI*); + + // Used to count the total number of HTTP requests made + void IncrementRequestNumber() { mTotalRequests++; } + uint32_t GetTotalRequestNumber() { return mTotalRequests; } + // Used to keep "race cache with network" stats + void IncrementCacheWonRequestNumber() { mCacheWon++; } + uint32_t GetCacheWonRequestNumber() { return mCacheWon; } + void IncrementNetWonRequestNumber() { mNetWon++; } + uint32_t GetNetWonRequestNumber() { return mNetWon; } + + // Used to trigger a recheck of the captive portal status + nsresult RecheckCaptivePortal(); + + void OnProcessLaunchComplete(SocketProcessHost* aHost, bool aSucceeded); + void OnProcessUnexpectedShutdown(SocketProcessHost* aHost); + bool SocketProcessReady(); + static void NotifySocketProcessPrefsChanged(const char* aName, void* aSelf); + void NotifySocketProcessPrefsChanged(const char* aName); + static bool UseSocketProcess(bool aCheckAgain = false); + + bool IsSocketProcessLaunchComplete(); + + // Call func immediately if socket process is launched completely. Otherwise, + // |func| will be queued and then executed in the *main thread* once socket + // process is launced. + void CallOrWaitForSocketProcess(const std::function<void()>& aFunc); + + int32_t SocketProcessPid(); + SocketProcessHost* SocketProcess() { return mSocketProcess; } + + friend SocketProcessMemoryReporter; + RefPtr<MemoryReportingProcess> GetSocketProcessMemoryReporter(); + + static void OnTLSPrefChange(const char* aPref, void* aSelf); + + nsresult LaunchSocketProcess(); + + private: + // These shouldn't be called directly: + // - construct using GetInstance + // - destroy using Release + nsIOService(); + ~nsIOService(); + nsresult SetConnectivityInternal(bool aConnectivity); + + nsresult OnNetworkLinkEvent(const char* data); + + nsresult GetCachedProtocolHandler(const char* scheme, + nsIProtocolHandler** hdlrResult, + uint32_t start = 0, uint32_t end = 0); + nsresult CacheProtocolHandler(const char* scheme, nsIProtocolHandler* hdlr); + + nsresult InitializeCaptivePortalService(); + nsresult RecheckCaptivePortalIfLocalRedirect(nsIChannel* newChan); + + // Prefs wrangling + static void PrefsChanged(const char* pref, void* self); + void PrefsChanged(const char* pref = nullptr); + void ParsePortList(const char* pref, bool remove); + + nsresult InitializeSocketTransportService(); + nsresult InitializeNetworkLinkService(); + nsresult InitializeProtocolProxyService(); + + // consolidated helper function + void LookupProxyInfo(nsIURI* aURI, nsIURI* aProxyURI, uint32_t aProxyFlags, + nsCString* aScheme, nsIProxyInfo** outPI); + + nsresult NewChannelFromURIWithProxyFlagsInternal( + nsIURI* aURI, nsIURI* aProxyURI, uint32_t aProxyFlags, + nsINode* aLoadingNode, nsIPrincipal* aLoadingPrincipal, + nsIPrincipal* aTriggeringPrincipal, + const mozilla::Maybe<mozilla::dom::ClientInfo>& aLoadingClientInfo, + const mozilla::Maybe<mozilla::dom::ServiceWorkerDescriptor>& aController, + uint32_t aSecurityFlags, nsContentPolicyType aContentPolicyType, + uint32_t aSandboxFlags, nsIChannel** result); + + nsresult NewChannelFromURIWithProxyFlagsInternal(nsIURI* aURI, + nsIURI* aProxyURI, + uint32_t aProxyFlags, + nsILoadInfo* aLoadInfo, + nsIChannel** result); + + nsresult SpeculativeConnectInternal(nsIURI* aURI, nsIPrincipal* aPrincipal, + nsIInterfaceRequestor* aCallbacks, + bool aAnonymous); + + void DestroySocketProcess(); + + private: + mozilla::Atomic<bool, mozilla::Relaxed> mOffline; + mozilla::Atomic<bool, mozilla::Relaxed> mOfflineForProfileChange; + bool mManageLinkStatus; + mozilla::Atomic<bool, mozilla::Relaxed> mConnectivity; + + // Used to handle SetOffline() reentrancy. See the comment in + // SetOffline() for more details. + bool mSettingOffline; + bool mSetOfflineValue; + + bool mSocketProcessLaunchComplete; + + mozilla::Atomic<bool, mozilla::Relaxed> mShutdown; + mozilla::Atomic<bool, mozilla::Relaxed> mHttpHandlerAlreadyShutingDown; + + nsCOMPtr<nsPISocketTransportService> mSocketTransportService; + nsCOMPtr<nsICaptivePortalService> mCaptivePortalService; + nsCOMPtr<nsINetworkLinkService> mNetworkLinkService; + bool mNetworkLinkServiceInitialized; + + // Cached protocol handlers, only accessed on the main thread + nsWeakPtr mWeakHandler[NS_N(gScheme)]; + + // cached categories + nsCategoryCache<nsIChannelEventSink> mChannelEventSinks; + + Mutex mMutex; + nsTArray<int32_t> mRestrictedPortList; + + uint32_t mTotalRequests; + uint32_t mCacheWon; + uint32_t mNetWon; + + // These timestamps are needed for collecting telemetry on PR_Connect, + // PR_ConnectContinue and PR_Close blocking time. If we spend very long + // time in any of these functions we want to know if and what network + // change has happened shortly before. + mozilla::Atomic<PRIntervalTime> mLastOfflineStateChange; + mozilla::Atomic<PRIntervalTime> mLastConnectivityChange; + mozilla::Atomic<PRIntervalTime> mLastNetworkLinkChange; + + // Time a network tearing down started. + mozilla::Atomic<PRIntervalTime> mNetTearingDownStarted; + + SocketProcessHost* mSocketProcess; + + // Events should be executed after the socket process is launched. Will + // dispatch these events while socket process fires OnProcessLaunchComplete. + // Note: this array is accessed only on the main thread. + nsTArray<std::function<void()>> mPendingEvents; + + // The observer notifications need to be forwarded to socket process. + nsTHashtable<nsCStringHashKey> mObserverTopicForSocketProcess; + // Some noticications (e.g., NS_XPCOM_SHUTDOWN_OBSERVER_ID) are triggered in + // socket process, so we should not send the notifications again. + nsTHashtable<nsCStringHashKey> mSocketProcessTopicBlackList; + + nsCOMPtr<nsIObserverService> mObserverService; + + public: + // Used for all default buffer sizes that necko allocates. + static uint32_t gDefaultSegmentSize; + static uint32_t gDefaultSegmentCount; +}; + +/** + * Reference to the IO service singleton. May be null. + */ +extern nsIOService* gIOService; + +} // namespace net +} // namespace mozilla + +#endif // nsIOService_h__ diff --git a/netwerk/base/nsIParentChannel.idl b/netwerk/base/nsIParentChannel.idl new file mode 100644 index 0000000000..137d1907bd --- /dev/null +++ b/netwerk/base/nsIParentChannel.idl @@ -0,0 +1,81 @@ +/* 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 "nsIStreamListener.idl" +#include "nsIHttpChannel.idl" + +interface nsIRemoteTab; + +%{C++ +namespace mozilla { +namespace net { +class ParentChannelListener; +} +} +%} + +[ptr] native ParentChannelListener(mozilla::net::ParentChannelListener); + +/** + * Implemented by chrome side of IPC protocols. + */ + +[scriptable, uuid(e0fc4801-6030-4653-a59f-1fb282bd1a04)] +interface nsIParentChannel : nsIStreamListener +{ + /** + * Called to set the ParentChannelListener object (optional). + */ + [noscript] void setParentListener(in ParentChannelListener listener); + + /** + * Called to notify the HttpChannelChild that flash plugin state has changed. + */ + [noscript] void notifyFlashPluginStateChanged(in nsIHttpChannel_FlashPluginState aState); + + /** + * Called to set matched information when URL matches SafeBrowsing list. + * @param aList + * Name of the list that matched + * @param aProvider + * Name of provider that matched + * @param aFullHash + * String represents full hash that matched + */ + [noscript] void setClassifierMatchedInfo(in ACString aList, + in ACString aProvider, + in ACString aFullHash); + + /** + * Called to set matched tracking information when URL matches tracking annotation list. + * @param aList + * Comma-separated list of tables that matched + * @param aFullHashes + * Comma-separated list of base64 encoded full hashes that matched + */ + [noscript] void setClassifierMatchedTrackingInfo(in ACString aLists, + in ACString aFullHashes); + + /** + * Called to notify the HttpChannelChild that the resource being loaded + * has been classified. + * @param aClassificationFlags + * What classifier identifies this channel. + * @param aIsThirdParty + * Whether or not the resourced is considered first-party + * with the URI of the window. + */ + [noscript] void notifyClassificationFlags(in uint32_t aClassificationFlags, + in bool aIsThirdParty); + + /** + * Called to invoke deletion of the IPC protocol. + */ + void delete(); + + /** + * The remote type of the target process for this load. + */ + readonly attribute AUTF8String remoteType; +}; diff --git a/netwerk/base/nsIParentRedirectingChannel.idl b/netwerk/base/nsIParentRedirectingChannel.idl new file mode 100644 index 0000000000..b2fe8c83d2 --- /dev/null +++ b/netwerk/base/nsIParentRedirectingChannel.idl @@ -0,0 +1,68 @@ +/* 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 "nsIParentChannel.idl" + +interface nsIRemoteTab; +interface nsIChannel; +interface nsIAsyncVerifyRedirectCallback; + +[builtinclass, uuid(01987690-48cf-45de-bae3-e143c2adc2a8)] +interface nsIAsyncVerifyRedirectReadyCallback : nsISupports +{ + /** + * Asynchronous callback when redirected channel finishes the preparation for + * completing the verification procedure. + * + * @param result + * SUCCEEDED if preparation for redirection verification succceed. + * If FAILED the redirection must be aborted. + */ + void readyToVerify(in nsresult result); +}; + +/** + * Implemented by chrome side of IPC protocols that support redirect responses. + */ + +[scriptable, uuid(3ed1d288-5324-46ee-8a98-33ac37d1080b)] +interface nsIParentRedirectingChannel : nsIParentChannel +{ + /** + * Called when the channel got a response that redirects it to a different + * URI. The implementation is responsible for calling the redirect observers + * on the child process and provide the decision result to the callback. + * + * @param newURI + * the URI we redirect to + * @param callback + * redirect result callback, usage is compatible with how + * nsIChannelEventSink defines it + */ + void startRedirect(in nsIChannel newChannel, + in uint32_t redirectFlags, + in nsIAsyncVerifyRedirectCallback callback); + + /** + * Called to new channel when the original channel got Redirect2Verify + * response from child. Callback will be invoked when the new channel + * finishes the preparation for Redirect2Verify and can be called immediately. + * + * @param callback + * redirect ready callback, will be called when redirect verification + * procedure can proceed. + */ + void continueVerification(in nsIAsyncVerifyRedirectReadyCallback callback); + + /** + * Called after we are done with redirecting process and we know if to + * redirect or not. Forward the redirect result to the child process. From + * that moment the nsIParentChannel implementation expects it will be + * forwarded all notifications from the 'real' channel. + * + * Primarilly used by ParentChannelListener::OnRedirectResult and kept as + * mActiveChannel and mRedirectChannel in that class. + */ + void completeRedirect(in boolean succeeded); +}; diff --git a/netwerk/base/nsIPermission.idl b/netwerk/base/nsIPermission.idl new file mode 100644 index 0000000000..1f6deb22f3 --- /dev/null +++ b/netwerk/base/nsIPermission.idl @@ -0,0 +1,89 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * 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 "nsISupports.idl" + +interface nsIPrincipal; +interface nsIURI; + +/** + * This interface defines a "permission" object, + * used to specify allowed/blocked objects from + * user-specified sites (cookies, images etc). + */ +[scriptable, uuid(bb409a51-2371-4fea-9dc9-b7286a458b8c)] +interface nsIPermission : nsISupports +{ + /** + * The principal for which this permission applies. + */ + readonly attribute nsIPrincipal principal; + + /** + * a case-sensitive ASCII string, indicating the type of permission + * (e.g., "cookie", "image", etc). + * This string is specified by the consumer when adding a permission + * via nsIPermissionManager. + * @see nsIPermissionManager + */ + readonly attribute ACString type; + + /** + * The permission (see nsIPermissionManager.idl for allowed values) + */ + readonly attribute uint32_t capability; + + /** + * The expiration type of the permission (session, time-based or none). + * Constants are EXPIRE_*, defined in nsIPermissionManager. + * @see nsIPermissionManager + */ + readonly attribute uint32_t expireType; + + /** + * The expiration time of the permission (milliseconds since Jan 1 1970 + * 0:00:00). + */ + readonly attribute int64_t expireTime; + + /** + * The last modification time of the permission (milliseconds since Jan 1 1970 + * 0:00:00). + */ + readonly attribute int64_t modificationTime; + + /** + * Test whether a principal would be affected by this permission. + * + * @param principal the principal to test + * @param exactHost If true, only the specific host will be matched, + * @see nsIPermissionManager::testExactPermission. + * If false, subdomains will also be searched, + * @see nsIPermissionManager::testPermission. + */ + boolean matches(in nsIPrincipal principal, + in boolean exactHost); + + /** + * Similar to matches() but the principal's URI should be just an origin + * (no path, no queryString, etc). + */ + [noscript] boolean matchesPrincipalForPermission(in nsIPrincipal principal, + in boolean exactHost); + + /** + * Test whether a URI would be affected by this permission. + * NOTE: This performs matches with default origin attribute values. + * + * @param uri the uri to test + * @param exactHost If true, only the specific host will be matched, + * @see nsIPermissionManager::testExactPermission. + * If false, subdomains will also be searched, + * @see nsIPermissionManager::testPermission. + */ + boolean matchesURI(in nsIURI uri, + in boolean exactHost); +}; diff --git a/netwerk/base/nsIPermissionManager.idl b/netwerk/base/nsIPermissionManager.idl new file mode 100644 index 0000000000..14ae70021f --- /dev/null +++ b/netwerk/base/nsIPermissionManager.idl @@ -0,0 +1,223 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +/** + * This file contains an interface to the Permission Manager, + * used to persistenly store permissions for different object types (cookies, + * images etc) on a site-by-site basis. + * + * This service broadcasts the following notification when the permission list + * is changed: + * + * topic : "perm-changed" (PERM_CHANGE_NOTIFICATION) + * broadcast whenever the permission list changes in some way. there + * are four possible data strings for this notification; one + * notification will be broadcast for each change, and will involve + * a single permission. + * subject: an nsIPermission interface pointer representing the permission object + * that changed. + * data : "deleted" + * a permission was deleted. the subject is the deleted permission. + * "added" + * a permission was added. the subject is the added permission. + * "changed" + * a permission was changed. the subject is the new permission. + * "cleared" + * the entire permission list was cleared. the subject is null. + */ + +#include "nsISupports.idl" + +interface nsIPrincipal; +interface nsIPermission; + +[scriptable, builtinclass, uuid(4dcb3851-eba2-4e42-b236-82d2596fca22)] +interface nsIPermissionManager : nsISupports +{ + /** + * Predefined return values for the testPermission method and for + * the permission param of the add method + * NOTE: UNKNOWN_ACTION (0) is reserved to represent the + * default permission when no entry is found for a host, and + * should not be used by consumers to indicate otherwise. + */ + const uint32_t UNKNOWN_ACTION = 0; + const uint32_t ALLOW_ACTION = 1; + const uint32_t DENY_ACTION = 2; + const uint32_t PROMPT_ACTION = 3; + + /** + * Predefined expiration types for permissions. Permissions can be permanent + * (never expire), expire at the end of the session, or expire at a specified + * time. Permissions that expire at the end of a session may also have a + * specified expiration time. + * + * EXPIRE_POLICY is a special expiration status. It is set when the permission + * is set by reading an enterprise policy. These permissions cannot be overridden. + */ + const uint32_t EXPIRE_NEVER = 0; + const uint32_t EXPIRE_SESSION = 1; + const uint32_t EXPIRE_TIME = 2; + const uint32_t EXPIRE_POLICY = 3; + + + /** + * Get all custom permissions for a given nsIPrincipal. This will return an + * enumerator of all permissions which are not set to default and which + * belong to the matching principal of the given nsIPrincipal. + * + * @param principal the URI to get all permissions for + */ + Array<nsIPermission> getAllForPrincipal(in nsIPrincipal principal); + + /** + * Get all custom permissions of a specific type, specified with a prefix + * string. This will return an array of all permissions which are not set to + * default. Also the passed type argument is either equal to or a prefix of + * the type of the returned permissions. + * + * @param prefix the type prefix string + */ + Array<nsIPermission> getAllWithTypePrefix(in ACString prefix); + + /** + * Get all custom permissions of a specific type and that were modified after + * the specified date. This will return an array of all permissions which are + * not set to default. + * + * @param type a case-sensitive ASCII string, identifying the permission. + * @param since a unix timestamp representing the number of milliseconds from + * Jan 1, 1970 00:00:00 UTC. + */ + Array<nsIPermission> getAllByTypeSince(in ACString type, in int64_t since); + + /** + * Add permission information for a given principal. + * It is internally calling the other add() method using the nsIURI from the + * principal. + * Passing a system principal will be a no-op because they will always be + * granted permissions. + */ + void addFromPrincipal(in nsIPrincipal principal, in ACString type, + in uint32_t permission, + [optional] in uint32_t expireType, + [optional] in int64_t expireTime); + + /** + * Remove permission information for a given principal. + * This is internally calling remove() with the host from the principal's URI. + * Passing system principal will be a no-op because we never add them to the + * database. + */ + void removeFromPrincipal(in nsIPrincipal principal, in ACString type); + + /** + * Remove the given permission from the permission manager. + * + * @param perm a permission obtained from the permission manager. + */ + void removePermission(in nsIPermission perm); + + /** + * Clear permission information for all websites. + */ + void removeAll(); + + /** + * Clear all permission information added since the specified time. + */ + void removeAllSince(in int64_t since); + + /** + * Clear all permissions of the passed type. + */ + void removeByType(in ACString type); + + /** + * Clear all permissions of the passed type added since the specified time. + * @param type a case-sensitive ASCII string, identifying the permission. + * @param since a unix timestamp representing the number of milliseconds from + * Jan 1, 1970 00:00:00 UTC. + */ + void removeByTypeSince(in ACString type, in int64_t since); + + /** + * Test whether the principal has the permission to perform a given action. + * System principals will always have permissions granted. + * This function will perform a pref lookup to permissions.default.<type> + * if the specific permission type is part of the whitelist for that functionality. + */ + uint32_t testPermissionFromPrincipal(in nsIPrincipal principal, + in ACString type); + + /** + * See testExactPermission() above. + * System principals will always have permissions granted. + * This function will perform a pref lookup to permissions.default.<type> + * if the specific permission type is part of the whitelist for that functionality. + */ + uint32_t testExactPermissionFromPrincipal(in nsIPrincipal principal, + in ACString type); + + /** + * Test whether a website has permission to perform the given action + * ignoring active sessions. + * System principals will always have permissions granted. + * This function will perform a pref lookup to permissions.default.<type> + * if the specific permission type is part of the whitelist for that functionality. + * + * @param principal the principal + * @param type a case-sensitive ASCII string, identifying the consumer + * @param return see add(), param permission. returns UNKNOWN_ACTION when + * there is no stored permission for this uri and / or type. + */ + uint32_t testExactPermanentPermission(in nsIPrincipal principal, + in ACString type); + + /** + * Get the permission object associated with the given principal and action. + * @param principal The principal + * @param type A case-sensitive ASCII string identifying the consumer + * @param exactHost If true, only the specific host will be matched, + * @see testExactPermission. If false, subdomains will + * also be searched, @see testPermission. + * @returns The matching permission object, or null if no matching object + * was found. No matching object is equivalent to UNKNOWN_ACTION. + * @note Clients in general should prefer the test* methods unless they + * need to know the specific stored details. + * @note This method will always return null for the system principal. + */ + nsIPermission getPermissionObject(in nsIPrincipal principal, + in ACString type, + in boolean exactHost); + + /** + * Returns all stored permissions. + * @return an array of nsIPermission objects + */ + readonly attribute Array<nsIPermission> all; + + /** + * Remove all permissions that will match the origin pattern. + */ + void removePermissionsWithAttributes(in AString patternAsJSON); + + /** + * Broadcasts permissions for the given principal to all content processes. + * + * DO NOT USE THIS METHOD if you can avoid it. It was added in bug XXX to + * handle the current temporary implementation of ServiceWorker debugging. It + * will be removed when service worker debugging is fixed. + * + * @param aPrincipal The principal to broadcast permissions for. + */ + void broadcastPermissionsForPrincipalToAllContentProcesses(in nsIPrincipal aPrincipal); +}; + +%{ C++ +#define NS_PERMISSIONMANAGER_CONTRACTID "@mozilla.org/permissionmanager;1" + +#define PERM_CHANGE_NOTIFICATION "perm-changed" +%} diff --git a/netwerk/base/nsIPrivateBrowsingChannel.idl b/netwerk/base/nsIPrivateBrowsingChannel.idl new file mode 100644 index 0000000000..3bc822f018 --- /dev/null +++ b/netwerk/base/nsIPrivateBrowsingChannel.idl @@ -0,0 +1,58 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +/** + * This interface is implemented by channels which support overriding the + * privacy state of the channel. + * + * This interface must be used only from the XPCOM main thread. + */ +[scriptable, uuid(df702bb0-55b8-11e2-bcfd-0800200c9a66)] +interface nsIPrivateBrowsingChannel : nsISupports +{ + /** + * Determine whether the channel is tied to a private browsing window. + * + * This value can be set only before the channel is opened. Setting it + * after that does not have any effect. This value overrides the privacy + * state of the channel, which means that if you call this method, then + * the loadGroup and load context will no longer be consulted when we + * need to know the private mode status for a channel. + * + * Note that this value is only meant to be used when the channel's privacy + * status cannot be obtained from the loadGroup or load context (for + * example, when the channel is not associated with any loadGroup or load + * context.) Setting this value directly should be avoided if possible. + * + * Implementations must enforce the ordering semantics of this function by + * raising errors if setPrivate is called on a channel which has a loadGroup + * and/or callbacks that implement nsILoadContext, or if the loadGroup + * or notificationCallbacks are set after setPrivate has been called. + * + * @param aPrivate whether the channel should be opened in private mode. + */ + void setPrivate(in boolean aPrivate); + + /** + * States whether the channel is in private browsing mode. This may either + * happen because the channel is opened from a private mode context or + * when the mode is explicitly set with ::setPrivate(). + * + * This attribute is equivalent to NS_UsePrivateBrowsing(), but scriptable. + */ + readonly attribute boolean isChannelPrivate; + + /* + * This function is used to determine whether the channel's private mode + * has been overridden by a call to setPrivate. It is intended to be used + * by NS_UsePrivateBrowsing(), and you should not call it directly. + * + * @param aValue the overridden value. This will only be set if the function + * returns true. + */ + [noscript] boolean isPrivateModeOverriden(out boolean aValue); +}; diff --git a/netwerk/base/nsIProgressEventSink.idl b/netwerk/base/nsIProgressEventSink.idl new file mode 100644 index 0000000000..5420239e4c --- /dev/null +++ b/netwerk/base/nsIProgressEventSink.idl @@ -0,0 +1,72 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +interface nsIURI; +interface nsIRequest; + +/** + * nsIProgressEventSink + * + * This interface is used to asynchronously convey channel status and progress + * information that is generally not critical to the processing of the channel. + * The information is intended to be displayed to the user in some meaningful + * way. + * + * An implementation of this interface can be passed to a channel via the + * channel's notificationCallbacks attribute. See nsIChannel for more info. + * + * The channel will begin passing notifications to the progress event sink + * after its asyncOpen method has been called. Notifications will cease once + * the channel calls its listener's onStopRequest method or once the channel + * is canceled (via nsIRequest::cancel). + * + * NOTE: This interface is actually not specific to channels and may be used + * with other implementations of nsIRequest. + */ +[scriptable, uuid(87d55fba-cb7e-4f38-84c1-5c6c2b2a55e9)] +interface nsIProgressEventSink : nsISupports +{ + /** + * Called to notify the event sink that progress has occurred for the + * given request. + * + * @param aRequest + * the request being observed (may QI to nsIChannel). + * @param aProgress + * numeric value in the range 0 to aProgressMax indicating the + * number of bytes transfered thus far. + * @param aProgressMax + * numeric value indicating maximum number of bytes that will be + * transfered (or -1 if total is unknown). + */ + void onProgress(in nsIRequest aRequest, + in long long aProgress, + in long long aProgressMax); + + /** + * Called to notify the event sink with a status message for the given + * request. + * + * @param aRequest + * the request being observed (may QI to nsIChannel). + * @param aStatus + * status code (not necessarily an error code) indicating the + * state of the channel (usually the state of the underlying + * transport). see nsISocketTransport for socket specific status + * codes. + * @param aStatusArg + * status code argument to be used with the string bundle service + * to convert the status message into localized, human readable + * text. the meaning of this parameter is specific to the value + * of the status code. for socket status codes, this parameter + * indicates the host:port associated with the status code. + */ + void onStatus(in nsIRequest aRequest, + in nsresult aStatus, + in wstring aStatusArg); + +}; diff --git a/netwerk/base/nsIPrompt.idl b/netwerk/base/nsIPrompt.idl new file mode 100644 index 0000000000..a1166d151d --- /dev/null +++ b/netwerk/base/nsIPrompt.idl @@ -0,0 +1,102 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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/. */ + +/** + * This is the prompt interface which can be used without knowlege of a + * parent window. The parentage is hidden by the GetInterface though + * which it is gotten. This interface is identical to nsIPromptService + * but without the parent nsIDOMWindow parameter. See nsIPromptService + * for all documentation. + * + * Accesskeys can be attached to buttons and checkboxes by inserting + * an & before the accesskey character. For a real &, use && instead. + */ + +#include "nsISupports.idl" + +[scriptable, uuid(a63f70c0-148b-11d3-9333-00104ba0fd40)] +interface nsIPrompt : nsISupports +{ + void alert(in wstring dialogTitle, + in wstring text); + + void alertCheck(in wstring dialogTitle, + in wstring text, + in wstring checkMsg, + inout boolean checkValue); + + boolean confirm(in wstring dialogTitle, + in wstring text); + + boolean confirmCheck(in wstring dialogTitle, + in wstring text, + in wstring checkMsg, + inout boolean checkValue); + + const unsigned long BUTTON_POS_0 = 1; + const unsigned long BUTTON_POS_1 = 1 << 8; + const unsigned long BUTTON_POS_2 = 1 << 16; + + const unsigned long BUTTON_TITLE_OK = 1; + const unsigned long BUTTON_TITLE_CANCEL = 2; + const unsigned long BUTTON_TITLE_YES = 3; + const unsigned long BUTTON_TITLE_NO = 4; + const unsigned long BUTTON_TITLE_SAVE = 5; + const unsigned long BUTTON_TITLE_DONT_SAVE = 6; + const unsigned long BUTTON_TITLE_REVERT = 7; + + const unsigned long BUTTON_TITLE_IS_STRING = 127; + + const unsigned long BUTTON_POS_0_DEFAULT = 0 << 24; + const unsigned long BUTTON_POS_1_DEFAULT = 1 << 24; + const unsigned long BUTTON_POS_2_DEFAULT = 2 << 24; + + /* used for security dialogs, buttons are initially disabled */ + const unsigned long BUTTON_DELAY_ENABLE = 1 << 26; + + const unsigned long STD_OK_CANCEL_BUTTONS = (BUTTON_TITLE_OK * BUTTON_POS_0) + + (BUTTON_TITLE_CANCEL * BUTTON_POS_1); + const unsigned long STD_YES_NO_BUTTONS = (BUTTON_TITLE_YES * BUTTON_POS_0) + + (BUTTON_TITLE_NO * BUTTON_POS_1); + + + // Indicates whether a prompt should be shown in-content, on tab level or as a separate window + const unsigned long MODAL_TYPE_CONTENT = 1; + const unsigned long MODAL_TYPE_TAB = 2; + const unsigned long MODAL_TYPE_WINDOW = 3; + + int32_t confirmEx(in wstring dialogTitle, + in wstring text, + in unsigned long buttonFlags, + in wstring button0Title, + in wstring button1Title, + in wstring button2Title, + in wstring checkMsg, + inout boolean checkValue); + + boolean prompt(in wstring dialogTitle, + in wstring text, + inout wstring value, + in wstring checkMsg, + inout boolean checkValue); + + boolean promptPassword(in wstring dialogTitle, + in wstring text, + inout wstring password, + in wstring checkMsg, + inout boolean checkValue); + + boolean promptUsernameAndPassword(in wstring dialogTitle, + in wstring text, + inout wstring username, + inout wstring password, + in wstring checkMsg, + inout boolean checkValue); + + boolean select(in wstring dialogTitle, + in wstring text, + in Array<AString> selectList, + out long outSelection); +}; diff --git a/netwerk/base/nsIProtocolHandler.idl b/netwerk/base/nsIProtocolHandler.idl new file mode 100644 index 0000000000..a323603238 --- /dev/null +++ b/netwerk/base/nsIProtocolHandler.idl @@ -0,0 +1,312 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +%{C++ +#include "nsCOMPtr.h" + +/** + * Protocol handlers are registered with XPCOM under the following CONTRACTID prefix: + */ +#define NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX "@mozilla.org/network/protocol;1?name=" +/** + * For example, "@mozilla.org/network/protocol;1?name=http" + */ + +#if defined(MOZ_THUNDERBIRD) || defined(MOZ_SUITE) +#define IS_ORIGIN_IS_FULL_SPEC_DEFINED 1 +#endif +%} + +interface nsIURI; +interface nsIChannel; +interface nsILoadInfo; + +/** + * nsIProtocolHandlerWithDynamicFlags + * + * Protocols that wish to return different flags depending on the URI should + * implement this interface. + */ +[scriptable, builtinclass, uuid(65a8e823-0591-4fc0-a56a-03265e0a4ce8)] +interface nsIProtocolHandlerWithDynamicFlags : nsISupports +{ + /* + * Returns protocol flags for the given URI, which may be different from the + * flags for another URI of the same scheme. + */ + unsigned long getFlagsForURI(in nsIURI aURI); +}; + +/** + * nsIProtocolHandler + */ +[scriptable, uuid(a87210e6-7c8c-41f7-864d-df809015193e)] +interface nsIProtocolHandler : nsISupports +{ + /** + * The scheme of this protocol (e.g., "file"). + */ + readonly attribute ACString scheme; + + /** + * The default port is the port that this protocol normally uses. + * If a port does not make sense for the protocol (e.g., "about:") + * then -1 will be returned. + */ + readonly attribute long defaultPort; + + /** + * Returns the protocol specific flags (see flag definitions below). + */ + readonly attribute unsigned long protocolFlags; + +%{C++ + // Helper method to get the protocol flags in the right way. + nsresult DoGetProtocolFlags(nsIURI* aURI, uint32_t* aFlags) + { + nsCOMPtr<nsIProtocolHandlerWithDynamicFlags> dh = do_QueryInterface(this); + nsresult rv = dh ? dh->GetFlagsForURI(aURI, aFlags) : GetProtocolFlags(aFlags); + if (NS_SUCCEEDED(rv)) { +#if !IS_ORIGIN_IS_FULL_SPEC_DEFINED + MOZ_RELEASE_ASSERT(!(*aFlags & nsIProtocolHandler::ORIGIN_IS_FULL_SPEC), + "ORIGIN_IS_FULL_SPEC is unsupported but used"); +#endif + } + return rv; + } +%} + + /** + * Constructs a new channel from the given URI for this protocol handler and + * sets the loadInfo for the constructed channel. + */ + nsIChannel newChannel(in nsIURI aURI, in nsILoadInfo aLoadinfo); + + /** + * Allows a protocol to override blacklisted ports. + * + * This method will be called when there is an attempt to connect to a port + * that is blacklisted. For example, for most protocols, port 25 (Simple Mail + * Transfer) is banned. When a URI containing this "known-to-do-bad-things" + * port number is encountered, this function will be called to ask if the + * protocol handler wants to override the ban. + */ + boolean allowPort(in long port, in string scheme); + + + /************************************************************************** + * Constants for the protocol flags (the first is the default mask, the + * others are deviations): + * + * NOTE: Implementation must ignore any flags they do not understand. + */ + + /** + * standard full URI with authority component and concept of relative + * URIs (http, ftp, ...) + */ + const unsigned long URI_STD = 0; + + /** + * no concept of relative URIs (about, javascript, finger, ...) + */ + const unsigned long URI_NORELATIVE = (1<<0); + + /** + * no authority component (file, ...) + */ + const unsigned long URI_NOAUTH = (1<<1); + + /** + * This protocol handler can be proxied via a proxy (socks or http) + * (e.g., irc, smtp, http, etc.). If the protocol supports transparent + * proxying, the handler should implement nsIProxiedProtocolHandler. + * + * If it supports only HTTP proxying, then it need not support + * nsIProxiedProtocolHandler, but should instead set the ALLOWS_PROXY_HTTP + * flag (see below). + * + * @see nsIProxiedProtocolHandler + */ + const unsigned long ALLOWS_PROXY = (1<<2); + + /** + * This protocol handler can be proxied using a http proxy (e.g., http, + * ftp, etc.). nsIIOService::newChannelFromURI will feed URIs from this + * protocol handler to the HTTP protocol handler instead. This flag is + * ignored if ALLOWS_PROXY is not set. + */ + const unsigned long ALLOWS_PROXY_HTTP = (1<<3); + + /** + * The URIs for this protocol have no inherent security context, so + * documents loaded via this protocol should inherit the security context + * from the document that loads them. + */ + const unsigned long URI_INHERITS_SECURITY_CONTEXT = (1<<4); + + /** + * "Automatic" loads that would replace the document (e.g. <meta> refresh, + * certain types of XLinks, possibly other loads that the application + * decides are not user triggered) are not allowed if the originating (NOT + * the target) URI has this protocol flag. Note that the decision as to + * what constitutes an "automatic" load is made externally, by the caller + * of nsIScriptSecurityManager::CheckLoadURI. See documentation for that + * method for more information. + * + * A typical protocol that might want to set this flag is a protocol that + * shows highly untrusted content in a viewing area that the user expects + * to have a lot of control over, such as an e-mail reader. + */ + const unsigned long URI_FORBIDS_AUTOMATIC_DOCUMENT_REPLACEMENT = (1<<5); + + /** + * +-------------------------------------------------------------------+ + * | | + * | ALL PROTOCOL HANDLERS MUST SET ONE OF THE FOLLOWING FIVE FLAGS. | + * | | + * +-------------------------------------------------------------------+ + * + * * URI_LOADABLE_BY_ANYONE + * * URI_DANGEROUS_TO_LOAD + * * URI_IS_UI_RESOURCE + * * URI_IS_LOCAL_FILE + * * URI_LOADABLE_BY_SUBSUMERS + * + * These flags are used to determine who is allowed to load URIs for this + * protocol. Note that if a URI is nested, only the flags for the + * innermost URI matter. See nsINestedURI. + * + * If none of these five flags are set, the ContentSecurityManager will + * deny the load. + */ + + /** + * The URIs for this protocol can be loaded by anyone. For example, any + * website should be allowed to trigger a load of a URI for this protocol. + * Web-safe protocols like "http" should set this flag. + */ + const unsigned long URI_LOADABLE_BY_ANYONE = (1<<6); + + /** + * The URIs for this protocol are UNSAFE if loaded by untrusted (web) + * content and may only be loaded by privileged code (for example, code + * which has the system principal). Various internal protocols should set + * this flag. + */ + const unsigned long URI_DANGEROUS_TO_LOAD = (1<<7); + + /** + * The URIs for this protocol point to resources that are part of the + * application's user interface. There are cases when such resources may + * be made accessible to untrusted content such as web pages, so this is + * less restrictive than URI_DANGEROUS_TO_LOAD but more restrictive than + * URI_LOADABLE_BY_ANYONE. See the documentation for + * nsIScriptSecurityManager::CheckLoadURI. + */ + const unsigned long URI_IS_UI_RESOURCE = (1<<8); + + /** + * Loading of URIs for this protocol from other origins should only be + * allowed if those origins should have access to the local filesystem. + * It's up to the application to decide what origins should have such + * access. Protocols like "file" that point to local data should set this + * flag. + */ + const unsigned long URI_IS_LOCAL_FILE = (1<<9); + + /** + * The URIs for this protocol can be loaded only by callers with a + * principal that subsumes this uri. For example, privileged code and + * websites that are same origin as this uri. + */ + const unsigned long URI_LOADABLE_BY_SUBSUMERS = (1<<10); + + /** + * Channels using this protocol never call OnDataAvailable + * on the listener passed to AsyncOpen and they therefore + * do not return any data that we can use. + */ + const unsigned long URI_DOES_NOT_RETURN_DATA = (1<<11); + + /** + * URIs for this protocol are considered to be local resources. This could + * be a local file (URI_IS_LOCAL_FILE), a UI resource (URI_IS_UI_RESOURCE), + * or something else that would not hit the network. + */ + const unsigned long URI_IS_LOCAL_RESOURCE = (1<<12); + + /** + * URIs for this protocol execute script when they are opened. + */ + const unsigned long URI_OPENING_EXECUTES_SCRIPT = (1<<13); + + /** + * Loading channels from this protocol has side-effects that make + * it unsuitable for saving to a local file. + */ + const unsigned long URI_NON_PERSISTABLE = (1<<14); + + /** + * URIs for this protocol require the webapps permission on the principal + * when opening URIs for a different domain. See bug#773886 + */ + const unsigned long URI_CROSS_ORIGIN_NEEDS_WEBAPPS_PERM = (1<<15); + + /** + * Channels for this protocol don't need to spin the event loop to handle + * Open() and reads on the resulting stream. + */ + const unsigned long URI_SYNC_LOAD_IS_OK = (1<<16); + + /** + * All the origins whose URI has this scheme are considered potentially + * trustworthy. + * Per the SecureContext spec, https: and wss: should be considered + * a priori secure, and implementations may consider other, + * implementation-specific URI schemes as secure. + */ + const unsigned long URI_IS_POTENTIALLY_TRUSTWORTHY = (1<<17); + + /** + * This URI may be fetched and the contents are visible to anyone. This is + * semantically equivalent to the resource being served with all-access CORS + * headers. + */ + const unsigned long URI_FETCHABLE_BY_ANYONE = (1 << 18); + + /** + * If this flag is set, then the origin for this protocol is the full URI + * spec, not just the scheme + host + port. + * + * Note: this is not supported in Firefox. It is currently only available + * in Thunderbird and SeaMonkey. + */ + const unsigned long ORIGIN_IS_FULL_SPEC = (1 << 19); + + /** + * If this flag is set, the URI does not always allow content using the same + * protocol to link to it. + */ + const unsigned long URI_SCHEME_NOT_SELF_LINKABLE = (1 << 20); + + /** + * The URIs for this protocol can be loaded by extensions. + */ + const unsigned long URI_LOADABLE_BY_EXTENSIONS = (1 << 21); + + /** + * The URIs for this protocol can not be loaded into private contexts. + */ + const unsigned long URI_DISALLOW_IN_PRIVATE_CONTEXT = (1 << 22); + + /** + * This protocol handler forbids accessing cookies e.g. for mail related + * protocols. Only used in Mailnews (comm-central). + */ + const unsigned long URI_FORBIDS_COOKIE_ACCESS = (1 << 23); +}; diff --git a/netwerk/base/nsIProtocolProxyCallback.idl b/netwerk/base/nsIProtocolProxyCallback.idl new file mode 100644 index 0000000000..96c2181eca --- /dev/null +++ b/netwerk/base/nsIProtocolProxyCallback.idl @@ -0,0 +1,42 @@ +/* -*- 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 "nsISupports.idl" + +interface nsIChannel; +interface nsIProxyInfo; +interface nsICancelable; + +/** + * This interface serves as a closure for nsIProtocolProxyService's + * asyncResolve method. + */ +[scriptable, uuid(fbb6eff6-0cc2-4d99-8d6f-0a12b462bdeb)] +interface nsIProtocolProxyCallback : nsISupports +{ + /** + * This method is called when proxy info is available or when an error + * in the proxy resolution occurs. + * + * @param aRequest + * The value returned from asyncResolve. + * @param aChannel + * The channel passed to asyncResolve. + * @param aProxyInfo + * The resulting proxy info or null if there is no associated proxy + * info for aURI. As with the result of nsIProtocolProxyService's + * resolve method, a null result implies that a direct connection + * should be used. + * @param aStatus + * The status of the callback. This is a failure code if the request + * could not be satisfied, in which case the value of aStatus + * indicates the reason for the failure and aProxyInfo will be null. + */ + void onProxyAvailable(in nsICancelable aRequest, + in nsIChannel aChannel, + in nsIProxyInfo aProxyInfo, + in nsresult aStatus); +}; diff --git a/netwerk/base/nsIProtocolProxyFilter.idl b/netwerk/base/nsIProtocolProxyFilter.idl new file mode 100644 index 0000000000..a771af5f43 --- /dev/null +++ b/netwerk/base/nsIProtocolProxyFilter.idl @@ -0,0 +1,97 @@ +/* -*- 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 "nsISupports.idl" + +interface nsIChannel; +interface nsIProtocolProxyService; +interface nsIProxyInfo; +interface nsIURI; + +/** + * Recipient of the result of implementers of nsIProtocolProxy(Channel)Filter + * allowing the proxyinfo be provided asynchronously. + */ +[scriptable, uuid(009E6C3F-FB64-40C5-8093-F1495C64773E)] +interface nsIProxyProtocolFilterResult : nsISupports +{ + /** + * It's mandatory to call this method exactly once when the applyFilter() + * implementation doesn't throw and to not call it when applyFilter() does + * throw. + * + * It's mandatory to call this method on the same thread as the call to + * applyFilter() has been made on. + * + * Following the above conditions, can be called either from within + * applyFilter() or asynchronouly any time later. + */ + void onProxyFilterResult(in nsIProxyInfo aProxy); +}; + +/** + * This interface is used to apply filters to the proxies selected for a given + * URI. Use nsIProtocolProxyService::registerFilter to hook up instances of + * this interface. See also nsIProtocolProxyChannelFilter. + */ +[scriptable, uuid(f424abd3-32b4-456c-9f45-b7e3376cb0d1)] +interface nsIProtocolProxyFilter : nsISupports +{ + /** + * This method is called to apply proxy filter rules for the given URI + * and proxy object (or list of proxy objects). + * + * @param aURI + * The URI for which these proxy settings apply. + * @param aProxy + * The proxy (or list of proxies) that would be used by default for + * the given URI. This may be null. + * + * @param aCallback + * An object that the implementer is obligated to call on with + * the result (from within applyFilter() or asynchronously) when + * applyFilter didn't throw. The argument passed to onProxyFilterResult + * is the proxy (or list of proxies) that should be used in place of + * aProxy. This can be just be aProxy if the filter chooses not to + * modify the proxy. It can also be null to indicate that a direct + * connection should be used. Use nsIProtocolProxyService.newProxyInfo + * to construct nsIProxyInfo objects. + */ + void applyFilter(in nsIURI aURI, in nsIProxyInfo aProxy, + in nsIProxyProtocolFilterResult aCallback); +}; + +/** + * This interface is used to apply filters to the proxies selected for a given + * channel. Use nsIProtocolProxyService::registerChannelFilter to hook up instances of + * this interface. See also nsIProtocolProxyFilter. + */ +[scriptable, uuid(245b0880-82c5-4e6e-be6d-bc586aa55a90)] +interface nsIProtocolProxyChannelFilter : nsISupports +{ + /** + * This method is called to apply proxy filter rules for the given channel + * and proxy object (or list of proxy objects). + * + * @param aChannel + * The channel for which these proxy settings apply. + * @param aProxy + * The proxy (or list of proxies) that would be used by default for + * the given channel. This may be null. + * + * @param aCallback + * An object that the implementer is obligated to call on with + * the result (from within applyFilter() or asynchronously) when + * applyFilter didn't throw. The argument passed to onProxyFilterResult + * is the proxy (or list of proxies) that should be used in place of + * aProxy. This can be just be aProxy if the filter chooses not to + * modify the proxy. It can also be null to indicate that a direct + * connection should be used. Use nsIProtocolProxyService.newProxyInfo + * to construct nsIProxyInfo objects. + */ + void applyFilter(in nsIChannel aChannel, in nsIProxyInfo aProxy, + in nsIProxyProtocolFilterResult aCallback); +}; diff --git a/netwerk/base/nsIProtocolProxyService.idl b/netwerk/base/nsIProtocolProxyService.idl new file mode 100644 index 0000000000..c07592d38a --- /dev/null +++ b/netwerk/base/nsIProtocolProxyService.idl @@ -0,0 +1,296 @@ +/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* vim:set ts=4 sw=4 sts=4 et: */ +/* 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 "nsISupports.idl" + +interface nsICancelable; +interface nsIProtocolProxyCallback; +interface nsIProtocolProxyFilter; +interface nsIProtocolProxyChannelFilter; +interface nsIProxyInfo; +interface nsIChannel; +interface nsIURI; +interface nsISerialEventTarget; + +/** + * nsIProtocolProxyService provides methods to access information about + * various network proxies. + */ +[scriptable, builtinclass, uuid(ef57c8b6-e09d-4cd4-9222-2a5d2402e15d)] +interface nsIProtocolProxyService : nsISupports +{ + /** Flag 1 << 0 is unused **/ + + /** + * When the proxy configuration is manual this flag may be passed to the + * resolve and asyncResolve methods to request to prefer the SOCKS proxy + * to HTTP ones. + */ + const unsigned long RESOLVE_PREFER_SOCKS_PROXY = 1 << 1; + + /** + * When the proxy configuration is manual this flag may be passed to the + * resolve and asyncResolve methods to request to not analyze the uri's + * scheme specific proxy. When this flag is set the main HTTP proxy is the + * preferred one. + * + * NOTE: if RESOLVE_PREFER_SOCKS_PROXY is set then the SOCKS proxy is + * the preferred one. + * + * NOTE: if RESOLVE_PREFER_HTTPS_PROXY is set then the HTTPS proxy + * is the preferred one. + */ + const unsigned long RESOLVE_IGNORE_URI_SCHEME = 1 << 2; + + /** + * When the proxy configuration is manual this flag may be passed to the + * resolve and asyncResolve methods to request to prefer the HTTPS proxy + * to the others HTTP ones. + * + * NOTE: RESOLVE_PREFER_SOCKS_PROXY takes precedence over this flag. + * + * NOTE: This flag implies RESOLVE_IGNORE_URI_SCHEME. + */ + const unsigned long RESOLVE_PREFER_HTTPS_PROXY = + (1 << 3) | RESOLVE_IGNORE_URI_SCHEME; + + /** + * When the proxy configuration is manual this flag may be passed to the + * resolve and asyncResolve methods to that all methods will be tunneled via + * CONNECT through the http proxy. + */ + const unsigned long RESOLVE_ALWAYS_TUNNEL = (1 << 4); + + /** + * This method returns via callback a nsIProxyInfo instance that identifies + * a proxy to be used for the given channel. Otherwise, this method returns + * null indicating that a direct connection should be used. + * + * @param aChannelOrURI + * The channel for which a proxy is to be found, or, if no channel is + * available, a URI indicating the same. This method will return + * NS_ERROR_NOINTERFACE if this argument isn't either an nsIURI or an + * nsIChannel. + * @param aFlags + * A bit-wise combination of the RESOLVE_ flags defined above. Pass + * 0 to specify the default behavior. Any additional bits that do + * not correspond to a RESOLVE_ flag are reserved for future use. + * @param aCallback + * The object to be notified when the result is available. + * @param aMainThreadTarget + * A labelled event target for dispatching runnables to main thread. + * + * @return An object that can be used to cancel the asychronous operation. + * If canceled, the cancelation status (aReason) will be forwarded + * to the callback's onProxyAvailable method via the aStatus param. + * + * NOTE: If this proxy is unavailable, getFailoverForProxy may be called + * to determine the correct secondary proxy to be used. + * + * NOTE: If the protocol handler for the given URI supports + * nsIProxiedProtocolHandler, then the nsIProxyInfo instance returned from + * resolve may be passed to the newProxiedChannel method to create a + * nsIChannel to the given URI that uses the specified proxy. + * + * NOTE: However, if the nsIProxyInfo type is "http", then it means that + * the given URI should be loaded using the HTTP protocol handler, which + * also supports nsIProxiedProtocolHandler. + * + * @see nsIProxiedProtocolHandler::newProxiedChannel + */ + nsICancelable asyncResolve( + in nsISupports aChannelOrURI, in unsigned long aFlags, + in nsIProtocolProxyCallback aCallback, + [optional] in nsISerialEventTarget aMainThreadTarget); + + /** + * This method may be called to construct a nsIProxyInfo instance from + * the given parameters. This method may be useful in conjunction with + * nsISocketTransportService::createTransport for creating, for example, + * a SOCKS connection. + * + * @param aType + * The proxy type. This is a string value that identifies the proxy + * type. Standard values include: + * "http" - specifies a HTTP proxy + * "https" - specifies HTTP proxying over TLS connection to proxy + * "socks" - specifies a SOCKS version 5 proxy + * "socks4" - specifies a SOCKS version 4 proxy + * "direct" - specifies a direct connection (useful for failover) + * The type name is case-insensitive. Other string values may be + * possible, and new types may be defined by a future version of + * this interface. + * @param aHost + * The proxy hostname or IP address. + * @param aPort + * The proxy port. + * @param aFlags + * Flags associated with this connection. See nsIProxyInfo.idl + * for currently defined flags. + * @param aFailoverTimeout + * Specifies the length of time (in seconds) to ignore this proxy if + * this proxy fails. Pass UINT32_MAX to specify the default + * timeout value, causing nsIProxyInfo::failoverTimeout to be + * assigned the default value. + * @param aFailoverProxy + * Specifies the next proxy to try if this proxy fails. This + * parameter may be null. + */ + nsIProxyInfo newProxyInfo(in ACString aType, in AUTF8String aHost, + in long aPort, + in ACString aProxyAuthorizationHeader, + in ACString aConnectionIsolationKey, + in unsigned long aFlags, + in unsigned long aFailoverTimeout, + in nsIProxyInfo aFailoverProxy); + + /** + * This method may be called to construct a nsIProxyInfo instance for + * with the specified username and password. + * Currently implemented for SOCKS proxies only. + * @param aType + * The proxy type. This is a string value that identifies the proxy + * type. Standard values include: + * "socks" - specifies a SOCKS version 5 proxy + * "socks4" - specifies a SOCKS version 4 proxy + * The type name is case-insensitive. Other string values may be + * possible, and new types may be defined by a future version of + * this interface. + * @param aHost + * The proxy hostname or IP address. + * @param aPort + * The proxy port. + * @param aUsername + * The proxy username + * @param aPassword + * The proxy password + * @param aFlags + * Flags associated with this connection. See nsIProxyInfo.idl + * for currently defined flags. + * @param aFailoverTimeout + * Specifies the length of time (in seconds) to ignore this proxy if + * this proxy fails. Pass UINT32_MAX to specify the default + * timeout value, causing nsIProxyInfo::failoverTimeout to be + * assigned the default value. + * @param aFailoverProxy + * Specifies the next proxy to try if this proxy fails. This + * parameter may be null. + */ + nsIProxyInfo newProxyInfoWithAuth(in ACString aType, in AUTF8String aHost, + in long aPort, + in ACString aUsername, in ACString aPassword, + in ACString aProxyAuthorizationHeader, + in ACString aConnectionIsolationKey, + in unsigned long aFlags, + in unsigned long aFailoverTimeout, + in nsIProxyInfo aFailoverProxy); + + /** + * If the proxy identified by aProxyInfo is unavailable for some reason, + * this method may be called to access an alternate proxy that may be used + * instead. As a side-effect, this method may affect future result values + * from resolve/asyncResolve as well as from getFailoverForProxy. + * + * @param aProxyInfo + * The proxy that was unavailable. + * @param aURI + * The URI that was originally passed to resolve/asyncResolve. + * @param aReason + * The error code corresponding to the proxy failure. This value + * may be used to tune the delay before this proxy is used again. + * + * @throw NS_ERROR_NOT_AVAILABLE if there is no alternate proxy available. + */ + nsIProxyInfo getFailoverForProxy(in nsIProxyInfo aProxyInfo, + in nsIURI aURI, + in nsresult aReason); + + /** + * This method may be used to register a proxy filter instance. Each proxy + * filter is registered with an associated position that determines the + * order in which the filters are applied (starting from position 0). When + * resolve/asyncResolve is called, it generates a list of proxies for the + * given URI, and then it applies the proxy filters. The filters have the + * opportunity to modify the list of proxies. + * + * If two filters register for the same position, then the filters will be + * visited in the order in which they were registered. + * + * If the filter is already registered, then its position will be updated. + * + * After filters have been run, any disabled or disallowed proxies will be + * removed from the list. A proxy is disabled if it had previously failed- + * over to another proxy (see getFailoverForProxy). A proxy is disallowed, + * for example, if it is a HTTP proxy and the nsIProtocolHandler for the + * queried URI does not permit proxying via HTTP. + * + * If a nsIProtocolHandler disallows all proxying, then filters will never + * have a chance to intercept proxy requests for such URLs. + * + * @param aFilter + * The nsIProtocolProxyFilter instance to be registered. + * @param aPosition + * The position of the filter. + * + * NOTE: It is possible to construct filters that compete with one another + * in undesirable ways. This API does not attempt to protect against such + * problems. It is recommended that any extensions that choose to call + * this method make their position value configurable at runtime (perhaps + * via the preferences service). + */ + void registerFilter(in nsIProtocolProxyFilter aFilter, + in unsigned long aPosition); + + /** + * Similar to registerFilter, but accepts an nsIProtocolProxyChannelFilter, + * which selects proxies according to channel rather than URI. + * + * @param aFilter + * The nsIProtocolProxyChannelFilter instance to be registered. + * @param aPosition + * The position of the filter. + */ + void registerChannelFilter(in nsIProtocolProxyChannelFilter aFilter, + in unsigned long aPosition); + + /** + * This method may be used to unregister a proxy filter instance. All + * filters will be automatically unregistered at XPCOM shutdown. + * + * @param aFilter + * The nsIProtocolProxyFilter instance to be unregistered. + */ + void unregisterFilter(in nsIProtocolProxyFilter aFilter); + + /** + * This method may be used to unregister a proxy channel filter instance. All + * filters will be automatically unregistered at XPCOM shutdown. + * + * @param aFilter + * The nsIProtocolProxyChannelFilter instance to be unregistered. + */ + void unregisterChannelFilter(in nsIProtocolProxyChannelFilter aFilter); + + /** + * These values correspond to the possible integer values for the + * network.proxy.type preference. + */ + const unsigned long PROXYCONFIG_DIRECT = 0; + const unsigned long PROXYCONFIG_MANUAL = 1; + const unsigned long PROXYCONFIG_PAC = 2; + const unsigned long PROXYCONFIG_WPAD = 4; + const unsigned long PROXYCONFIG_SYSTEM = 5; + + /** + * This attribute specifies the current type of proxy configuration. + */ + readonly attribute unsigned long proxyConfigType; + + /** + * True if there is a PAC download in progress. + */ + [notxpcom, nostdcall] readonly attribute boolean isPACLoading; +}; diff --git a/netwerk/base/nsIProtocolProxyService2.idl b/netwerk/base/nsIProtocolProxyService2.idl new file mode 100644 index 0000000000..fe031bac40 --- /dev/null +++ b/netwerk/base/nsIProtocolProxyService2.idl @@ -0,0 +1,32 @@ +/* -*- 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 "nsIProtocolProxyService.idl" + +/** + * An extension of nsIProtocolProxyService + */ +[scriptable, builtinclass, uuid(b2e5b2c0-e21e-4845-b336-be6d60a38951)] +interface nsIProtocolProxyService2 : nsIProtocolProxyService +{ + /** + * Call this method to cause the PAC file (if any is configured) to be + * reloaded. The PAC file is loaded asynchronously. + */ + void reloadPAC(); + + /** + * This method is identical to asyncResolve() except: + * - it only accepts an nsIChannel, not an nsIURI; + * - it may execute the callback function immediately (i.e from the stack + * of asyncResolve2()) if it is immediately ready to run. + * The nsICancelable return value will be null in that case. + */ + nsICancelable asyncResolve2( + in nsIChannel aChannel, in unsigned long aFlags, + in nsIProtocolProxyCallback aCallback, + [optional] in nsISerialEventTarget aMainThreadTarget); +}; diff --git a/netwerk/base/nsIProxiedChannel.idl b/netwerk/base/nsIProxiedChannel.idl new file mode 100644 index 0000000000..c6796b9f9d --- /dev/null +++ b/netwerk/base/nsIProxiedChannel.idl @@ -0,0 +1,36 @@ +/* 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 "nsISupports.idl" + +interface nsIProxyInfo; + +/** + * An interface for accessing the proxy info that a channel was + * constructed with. + * + * @see nsIProxiedProtocolHandler + */ +[scriptable, uuid(6238f134-8c3f-4354-958f-dfd9d54a4446)] +interface nsIProxiedChannel : nsISupports +{ + /** + * Gets the proxy info the channel was constructed with. null or a + * proxyInfo with type "direct" mean no proxy. + * + * The returned proxy info must not be modified. + */ + readonly attribute nsIProxyInfo proxyInfo; + + /** + * The HTTP response code returned from the proxy to the CONNECT method. + * The response code is only available when we get the response from + * the proxy server, so this value is known in and after OnStartRequest. + * + * If CONNECT method is not used, httpProxyConnectResponseCode is always -1. + * After OnStartRequest, httpProxyConnectResponseCode is the real HTTP + * response code or 0 if we can't reach to the proxy. + */ + readonly attribute int32_t httpProxyConnectResponseCode; +}; diff --git a/netwerk/base/nsIProxiedProtocolHandler.idl b/netwerk/base/nsIProxiedProtocolHandler.idl new file mode 100644 index 0000000000..d9436e94a7 --- /dev/null +++ b/netwerk/base/nsIProxiedProtocolHandler.idl @@ -0,0 +1,36 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsIProtocolHandler.idl" + +interface nsIChannel; +interface nsIURI; +interface nsIProxyInfo; +interface nsILoadInfo; + +[scriptable, builtinclass, uuid(3756047a-fa2b-4b45-9948-3b5f8fc375e7)] +interface nsIProxiedProtocolHandler : nsIProtocolHandler +{ + /** Create a new channel with the given proxyInfo + * + * @param uri the channel uri + * @param proxyInfo any proxy information that has already been determined, + * or null if channel should later determine the proxy on its own using + * proxyResolveFlags/proxyURI + * @param proxyResolveFlags used if the proxy is later determined + * from nsIProtocolProxyService::asyncResolve + * @param proxyURI used if the proxy is later determined from + * nsIProtocolProxyService::asyncResolve with this as the proxyURI name. + * Generally this is the same as uri (or null which has the same + * effect), except in the case of websockets which wants to bootstrap + * to an http:// channel but make its proxy determination based on + * a ws:// uri. + * @param aLoadInfo used to evaluate who initated the resource request. + */ + nsIChannel newProxiedChannel(in nsIURI uri, in nsIProxyInfo proxyInfo, + in unsigned long proxyResolveFlags, + in nsIURI proxyURI, + in nsILoadInfo aLoadInfo); +}; diff --git a/netwerk/base/nsIProxyInfo.idl b/netwerk/base/nsIProxyInfo.idl new file mode 100644 index 0000000000..593fc3740f --- /dev/null +++ b/netwerk/base/nsIProxyInfo.idl @@ -0,0 +1,100 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +/** + * This interface identifies a proxy server. + */ +[scriptable, uuid(63fff172-2564-4138-96c6-3ae7d245fbed)] +interface nsIProxyInfo : nsISupports +{ + /** + * This attribute specifies the hostname of the proxy server. + */ + readonly attribute AUTF8String host; + + /** + * This attribute specifies the port number of the proxy server. + */ + readonly attribute long port; + + /** + * This attribute specifies the type of the proxy server as an ASCII string. + * + * Some special values for this attribute include (but are not limited to) + * the following: + * "http" HTTP proxy (or SSL CONNECT for HTTPS) + * "https" HTTP proxying over TLS connection to proxy + * "socks" SOCKS v5 proxy + * "socks4" SOCKS v4 proxy + * "direct" no proxy + * "unknown" unknown proxy (see nsIProtocolProxyService::resolve) + * + * A future version of this interface may define additional types. + */ + readonly attribute ACString type; + + /** + * This attribute specifies flags that modify the proxy type. The value of + * this attribute is the bit-wise combination of the Proxy Flags defined + * below. Any undefined bits are reserved for future use. + */ + readonly attribute unsigned long flags; + + /** + * This attribute specifies flags that were used by nsIProxyProtocolService when + * creating this ProxyInfo element. + */ + attribute unsigned long resolveFlags; + + /** + * Specifies a proxy username. + */ + readonly attribute ACString username; + + /** + * Specifies a proxy password. + */ + readonly attribute ACString password; + + /** + * This attribute specifies the failover timeout in seconds for this proxy. + * If a nsIProxyInfo is reported as failed via nsIProtocolProxyService:: + * getFailoverForProxy, then the failed proxy will not be used again for this + * many seconds. + */ + readonly attribute unsigned long failoverTimeout; + + /** + * This attribute specifies the proxy to failover to when this proxy fails. + */ + attribute nsIProxyInfo failoverProxy; + + /** + * Any non-empty value will be passed directly as Proxy-Authorization header + * value for the CONNECT request attempt. However, this header set on the + * resource request itself takes precedence. + */ + readonly attribute ACString proxyAuthorizationHeader; + + /** + * An optional key used for additional isolation of this proxy connection. + */ + readonly attribute ACString connectionIsolationKey; + + /**************************************************************************** + * The following "Proxy Flags" may be bit-wise combined to construct the + * flags attribute defined on this interface. All unspecified bits are + * reserved for future use. + */ + + /** + * This flag is set if the proxy is to perform name resolution itself. If + * this is the case, the hostname is used in some fashion, and we shouldn't + * do any form of DNS lookup ourselves. + */ + const unsigned short TRANSPARENT_PROXY_RESOLVES_HOST = 1 << 0; +}; diff --git a/netwerk/base/nsIRandomGenerator.idl b/netwerk/base/nsIRandomGenerator.idl new file mode 100644 index 0000000000..29ee25bbe1 --- /dev/null +++ b/netwerk/base/nsIRandomGenerator.idl @@ -0,0 +1,24 @@ +/* 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 "nsISupports.idl" + +/** + * Interface used to generate random data. + * + * @threadsafe + */ +[scriptable, uuid(2362d97a-747a-4576-8863-697667309209)] +interface nsIRandomGenerator : nsISupports { + /** + * Generates the specified amount of random bytes. + * + * @param aLength + * The length of the data to generate. + * @param aBuffer + * A buffer that contains random bytes of size aLength. + */ + void generateRandomBytes(in unsigned long aLength, + [retval, array, size_is(aLength)] out octet aBuffer); +}; diff --git a/netwerk/base/nsIRedirectChannelRegistrar.idl b/netwerk/base/nsIRedirectChannelRegistrar.idl new file mode 100644 index 0000000000..02c8abdaaf --- /dev/null +++ b/netwerk/base/nsIRedirectChannelRegistrar.idl @@ -0,0 +1,72 @@ +/* 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 "nsISupports.idl" + +interface nsIChannel; +interface nsIParentChannel; + +/** + * Used on the chrome process as a service to join channel implementation + * and parent IPC protocol side under a unique id. Provides this way a generic + * communication while redirecting to various protocols. + * + * See also nsIChildChannel and nsIParentChannel. + */ + +[scriptable, uuid (efa36ea2-5b07-46fc-9534-a5acb8b77b72)] +interface nsIRedirectChannelRegistrar : nsISupports +{ + /** + * Register the redirect target channel. The passed id needs to be a + * unique ID for that channel (see `nsContentUtils::GenerateLoadIdentifier`). + * + * Primarily used in ParentChannelListener::AsyncOnChannelRedirect to get + * a channel id sent to the HttpChannelChild being redirected. + */ + void registerChannel(in nsIChannel channel, in uint64_t id); + + /** + * First, search for the channel registered under the id. If found return + * it. Then, register under the same id the parent side of IPC protocol + * to let it be later grabbed back by the originator of the redirect and + * notifications from the real channel could be forwarded to this parent + * channel. + * + * Primarily used in parent side of an IPC protocol implementation + * in reaction to nsIChildChannel.connectParent(id) called from the child + * process. + */ + nsIChannel linkChannels(in uint64_t id, in nsIParentChannel channel); + + /** + * Returns back the channel previously registered under the ID with + * registerChannel method. + * + * Primarilly used in chrome IPC side of protocols when attaching a redirect + * target channel to an existing 'real' channel implementation. + */ + nsIChannel getRegisteredChannel(in uint64_t id); + + /** + * Returns the stream listener that shall be attached to the redirect target + * channel, all notification from the redirect target channel will be + * forwarded to this stream listener. + * + * Primarilly used in ParentChannelListener::OnRedirectResult callback + * to grab the created parent side of the channel and forward notifications + * to it. + */ + nsIParentChannel getParentChannel(in uint64_t id); + + /** + * To not force all channel implementations to support weak reference + * consumers of this service must ensure release of registered channels them + * self. This releases both the real and parent channel registered under + * the id. + * + * Primarilly used in ParentChannelListener::OnRedirectResult callback. + */ + void deregisterChannels(in uint64_t id); +}; diff --git a/netwerk/base/nsIRedirectHistoryEntry.idl b/netwerk/base/nsIRedirectHistoryEntry.idl new file mode 100644 index 0000000000..50086574f8 --- /dev/null +++ b/netwerk/base/nsIRedirectHistoryEntry.idl @@ -0,0 +1,34 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +interface nsIPrincipal; +interface nsIURI; + +/** + * This nsIRedirectHistoryEntry defines an interface for specifying channel + * redirect information + */ + +[scriptable, uuid(133b2905-0eba-411c-a8bb-f59787142aa2)] +interface nsIRedirectHistoryEntry : nsISupports +{ + /** + * The principal of this redirect entry + */ + readonly attribute nsIPrincipal principal; + + /** + * The referring URI of this redirect entry. This may be null. + */ + readonly attribute nsIURI referrerURI; + + /** + * The remote address of this redirect entry. + */ + readonly attribute ACString remoteAddress; + +}; diff --git a/netwerk/base/nsIRedirectResultListener.idl b/netwerk/base/nsIRedirectResultListener.idl new file mode 100644 index 0000000000..1afb3e9ecc --- /dev/null +++ b/netwerk/base/nsIRedirectResultListener.idl @@ -0,0 +1,22 @@ +/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * 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 "nsISupports.idl" + +[scriptable, uuid(85cd2640-e91e-41ac-bdca-1dbf10dc131e)] +interface nsIRedirectResultListener : nsISupports +{ + /** + * When an HTTP redirect has been processed (either successfully or not) + * nsIHttpChannel will call this function if its callbacks implement this + * interface. + * + * @param proceeding + * Indicated whether the redirect will be proceeding, or not (i.e. + * has been canceled, or failed). + */ + void onRedirectResult(in boolean proceeding); +}; diff --git a/netwerk/base/nsIRequest.idl b/netwerk/base/nsIRequest.idl new file mode 100644 index 0000000000..6473d02d00 --- /dev/null +++ b/netwerk/base/nsIRequest.idl @@ -0,0 +1,291 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +interface nsILoadGroup; + +typedef unsigned long nsLoadFlags; + +/** + * nsIRequest + */ +[scriptable, uuid(ef6bfbd2-fd46-48d8-96b7-9f8f0fd387fe)] +interface nsIRequest : nsISupports +{ + /** + * The name of the request. Often this is the URI of the request. + */ + readonly attribute AUTF8String name; + + /** + * Indicates whether the request is pending. nsIRequest::isPending is + * true when there is an outstanding asynchronous event that will make + * the request no longer be pending. Requests do not necessarily start + * out pending; in some cases, requests have to be explicitly initiated + * (e.g. nsIChannel implementations are only pending once asyncOpen + * returns successfully). + * + * Requests can become pending multiple times during their lifetime. + * + * @return TRUE if the request has yet to reach completion. + * @return FALSE if the request has reached completion (e.g., after + * OnStopRequest has fired). + * @note Suspended requests are still considered pending. + */ + boolean isPending(); + + /** + * The error status associated with the request. + */ + readonly attribute nsresult status; + + /** + * Cancels the current request. This will close any open input or + * output streams and terminate any async requests. Users should + * normally pass NS_BINDING_ABORTED, although other errors may also + * be passed. The error passed in will become the value of the + * status attribute. + * + * Implementations must not send any notifications (e.g. via + * nsIRequestObserver) synchronously from this function. Similarly, + * removal from the load group (if any) must also happen asynchronously. + * + * Requests that use nsIStreamListener must not call onDataAvailable + * anymore after cancel has been called. + * + * @param aStatus the reason for canceling this request. + * + * NOTE: most nsIRequest implementations expect aStatus to be a + * failure code; however, some implementations may allow aStatus to + * be a success code such as NS_OK. In general, aStatus should be + * a failure code. + */ + void cancel(in nsresult aStatus); + + /** + * Suspends the current request. This may have the effect of closing + * any underlying transport (in order to free up resources), although + * any open streams remain logically opened and will continue delivering + * data when the transport is resumed. + * + * Calling cancel() on a suspended request must not send any + * notifications (such as onstopRequest) until the request is resumed. + * + * NOTE: some implementations are unable to immediately suspend, and + * may continue to deliver events already posted to an event queue. In + * general, callers should be capable of handling events even after + * suspending a request. + */ + void suspend(); + + /** + * Resumes the current request. This may have the effect of re-opening + * any underlying transport and will resume the delivery of data to + * any open streams. + */ + void resume(); + + /** + * The load group of this request. While pending, the request is a + * member of the load group. It is the responsibility of the request + * to implement this policy. + */ + attribute nsILoadGroup loadGroup; + + /** + * The load flags of this request. Bits 0-15 are reserved. + * + * When added to a load group, this request's load flags are merged with + * the load flags of the load group. + */ + attribute nsLoadFlags loadFlags; + + /** + * Mask defining the bits reserved for nsIRequest LoadFlags + */ + const unsigned long LOAD_REQUESTMASK = 0xFFFF; + + /************************************************************************** + * Listed below are the various load flags which may be or'd together. + */ + + /** + * No special load flags: + */ + const unsigned long LOAD_NORMAL = 0; + + /** + * Do not deliver status notifications to the nsIProgressEventSink and + * do not block the loadgroup from completing (should this load belong to one). + * Note: Progress notifications will still be delivered. + */ + const unsigned long LOAD_BACKGROUND = 1 << 0; + + /** + * This flag marks the request as being made to load the data for an html + * <object> tag. This means that the LOAD_DOCUMENT_URI flag may be set after + * the channel has been provided with the MIME type. + */ + const unsigned long LOAD_HTML_OBJECT_DATA = 1 << 1; + + /** + * This flag marks the request as belonging to a document that requires access + * to the document.cookies API. + */ + const unsigned long LOAD_DOCUMENT_NEEDS_COOKIE = 1 << 2; + + cenum TRRMode : 8 { + TRR_DEFAULT_MODE = 0, + TRR_DISABLED_MODE = 1, + TRR_FIRST_MODE = 2, + TRR_ONLY_MODE = 3 + }; + + /** + * These methods encode/decode the TRR mode to/from the loadFlags. + * Helper methods Get/SetTRRModeImpl are provided so implementations don't + * need to duplicate code. + * + * Requests with TRR_DEFAULT_MODE will use the mode indicated by the pref + * - see network.trr.mode in all.js + * Requests with TRR_DISABLED_MODE will always use native DNS, even if the + * pref is set to mode3 (TRR-only). + * Requests with TRR_DISABLED_MODE will first use TRR then fallback to + * regular DNS, unless TRR is disabled by setting the pref to mode5, + * parental control being enabled, or the domain being in the exclusion + * list. + * Requests with TRR_ONLY_MODE will only use TRR, unless not allowed by + * the same conditions mentioned above. + */ + nsIRequest_TRRMode getTRRMode(); + void setTRRMode(in nsIRequest_TRRMode mode); + + %{C++ + inline TRRMode GetTRRMode() { + TRRMode mode = TRR_DEFAULT_MODE; + GetTRRMode(&mode); + return mode; + } + + inline nsresult GetTRRModeImpl(nsIRequest::TRRMode* aTRRMode) { + NS_ENSURE_ARG_POINTER(aTRRMode); + nsLoadFlags flags = nsIRequest::LOAD_NORMAL; + nsresult rv = GetLoadFlags(&flags); + if (NS_FAILED(rv)) { + return rv; + } + *aTRRMode = static_cast<nsIRequest::TRRMode>( + (flags & nsIRequest::LOAD_TRR_MASK) >> 3); + return NS_OK; + } + + inline nsresult SetTRRModeImpl(nsIRequest::TRRMode aTRRMode) { + MOZ_ASSERT(aTRRMode <= 3, "invalid value"); + nsLoadFlags flags = nsIRequest::LOAD_NORMAL; + nsresult rv = GetLoadFlags(&flags); + if (NS_FAILED(rv)) { + return rv; + } + flags = (flags & ~nsIRequest::LOAD_TRR_MASK) | (aTRRMode << 3); + return SetLoadFlags(flags); + } + %} + + /** + * These two bits encode the TRR mode. + * Do not get/set manually, rather use the getTRRMode/setTRRMode methods. + */ + const unsigned long LOAD_TRR_MASK = (1 << 3) | (1 << 4); + const unsigned long LOAD_TRR_DISABLED_MODE = 1 << 3; + const unsigned long LOAD_TRR_FIRST_MODE = 1 << 4; + const unsigned long LOAD_TRR_ONLY_MODE = (1 << 3) | (1 << 4); + + /************************************************************************** + * The following flags control the flow of data into the cache. + */ + + /** + * This flag prevents caching of any kind. It does not, however, prevent + * cached content from being used to satisfy this request. + */ + const unsigned long INHIBIT_CACHING = 1 << 7; + + /** + * This flag prevents caching on disk (or other persistent media), which + * may be needed to preserve privacy. + */ + const unsigned long INHIBIT_PERSISTENT_CACHING = 1 << 8; + + /************************************************************************** + * The following flags control what happens when the cache contains data + * that could perhaps satisfy this request. They are listed in descending + * order of precidence. + */ + + /** + * Force an end-to-end download of content data from the origin server. + * This flag is used for a shift-reload. + */ + const unsigned long LOAD_BYPASS_CACHE = 1 << 9; + + /** + * Attempt to force a load from the cache, bypassing ALL validation logic + * (note: this is stronger than VALIDATE_NEVER, which still validates for + * certain conditions). + * + * If the resource is not present in cache, it will be loaded from the + * network. Combine this flag with LOAD_ONLY_FROM_CACHE if you wish to + * perform cache-only loads without validation checks. + * + * This flag is used when browsing via history. It is not recommended for + * normal browsing as it may likely violate reasonable assumptions made by + * the server and confuse users. + */ + const unsigned long LOAD_FROM_CACHE = 1 << 10; + + /** + * The following flags control the frequency of cached content validation + * when neither LOAD_BYPASS_CACHE or LOAD_FROM_CACHE are set. By default, + * cached content is automatically validated if necessary before reuse. + * + * VALIDATE_ALWAYS forces validation of any cached content independent of + * its expiration time (unless it is https with Cache-Control: immutable) + * + * VALIDATE_NEVER disables validation of cached content, unless it arrived + * with the "Cache: no-store" header, or arrived via HTTPS with the + * "Cache: no-cache" header. + * + * VALIDATE_ONCE_PER_SESSION disables validation of expired content, + * provided it has already been validated (at least once) since the start + * of this session. + * + * NOTE TO IMPLEMENTORS: + * These flags are intended for normal browsing, and they should therefore + * not apply to content that must be validated before each use. Consider, + * for example, a HTTP response with a "Cache-control: no-cache" header. + * According to RFC2616, this response must be validated before it can + * be taken from a cache. Breaking this requirement could result in + * incorrect and potentially undesirable side-effects. + */ + const unsigned long VALIDATE_ALWAYS = 1 << 11; + const unsigned long VALIDATE_NEVER = 1 << 12; + const unsigned long VALIDATE_ONCE_PER_SESSION = 1 << 13; + + /** + * When set, this flag indicates that no user-specific data should be added + * to the request when opened. This means that things like authorization + * tokens or cookie headers should not be added. + */ + const unsigned long LOAD_ANONYMOUS = 1 << 14; + + /** + * When set, this flag indicates that caches of network connections, + * particularly HTTP persistent connections, should not be used. + * Use this together with LOAD_INITIAL_DOCUMENT_URI as otherwise it has no + * effect. + */ + const unsigned long LOAD_FRESH_CONNECTION = 1 << 15; +}; diff --git a/netwerk/base/nsIRequestContext.idl b/netwerk/base/nsIRequestContext.idl new file mode 100644 index 0000000000..6c9f265af2 --- /dev/null +++ b/netwerk/base/nsIRequestContext.idl @@ -0,0 +1,158 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +%{C++ +// Forward-declare mozilla::net::SpdyPushCache +namespace mozilla { +namespace net { +class SpdyPushCache; +} +} +%} + +interface nsILoadGroup; +interface nsIChannel; +interface nsIStreamListener; + +[ptr] native SpdyPushCachePtr(mozilla::net::SpdyPushCache); + +/** + * Requests capable of tail-blocking must implement this + * interfaces (typically channels). + * If the request is tail-blocked, it will be held in its request + * context queue until unblocked. + */ +[uuid(7EB361D4-37A5-42C9-AFAE-F6C88FE7C394)] +interface nsIRequestTailUnblockCallback : nsISupports +{ + /** + * Called when the requests is unblocked and proceed. + * @param result + * NS_OK - the request is OK to go, unblocking is not + * caused by cancelation of the request. + * any error - the request must behave as it were canceled + * with the result as status. + */ + void onTailUnblock(in nsresult aResult); +}; + +/** + * The nsIRequestContext is used to maintain state about connections + * that are in some way associated with each other (often by being part + * of the same load group) and how they interact with blocking items like + * HEAD css/js loads. + * + * This used to be known as nsILoadGroupConnectionInfo and nsISchedulingContext. + */ +[uuid(658e3e6e-8633-4b1a-8d66-fa9f72293e63)] +interface nsIRequestContext : nsISupports +{ + /** + * A unique identifier for this request context + */ + [notxpcom, nostdcall] readonly attribute unsigned long long ID; + + /** + * Called by the associated document when its load starts. This resets + * context's internal states. + */ + void beginLoad(); + + /** + * Called when the associated document notified the DOMContentLoaded event. + */ + void DOMContentLoaded(); + + /** + * Number of active blocking transactions associated with this context + */ + readonly attribute unsigned long blockingTransactionCount; + + /** + * Increase the number of active blocking transactions associated + * with this context by one. + */ + void addBlockingTransaction(); + + /** + * Decrease the number of active blocking transactions associated + * with this context by one. The return value is the number of remaining + * blockers. + */ + unsigned long removeBlockingTransaction(); + + /** + * This gives out a weak pointer to the push cache. + * The nsIRequestContext implementation owns the cache + * and will destroy it when overwritten or when the context + * ends. + */ + [notxpcom,nostdcall] attribute SpdyPushCachePtr spdyPushCache; + + /** + * Increases/decrease the number of non-tailed requests in this context. + * If the count drops to zero, all tail-blocked callbacks are notified + * shortly after that to be unblocked. + */ + void addNonTailRequest(); + void removeNonTailRequest(); + + /** + * If the request context is in tail-blocked state, the callback + * is queued and result is true. The callback will be notified + * about tail-unblocking or when the request context is canceled. + */ + [must_use] boolean isContextTailBlocked(in nsIRequestTailUnblockCallback callback); + + /** + * Called when the request is sitting in the tail queue but has been + * canceled before untailing. This just removes the request from the + * queue so that it is not notified on untail and not referenced. + */ + void cancelTailedRequest(in nsIRequestTailUnblockCallback request); + + /** + * This notifies all queued tail-blocked requests, they will be notified + * aResult and released afterwards. Called by the load group when + * it's canceled. + */ + void cancelTailPendingRequests(in nsresult aResult); +}; + +/** + * The nsIRequestContextService is how anyone gets access to a request + * context when they haven't been explicitly given a strong reference to an + * existing one. It is responsible for creating and handing out strong + * references to nsIRequestContexts, but only keeps weak references itself. + * The shared request context will go away once no one else is keeping a + * reference to it. If you ask for a request context that has no one else + * holding a reference to it, you'll get a brand new request context. Anyone + * who asks for the same request context while you're holding a reference + * will get a reference to the same request context you have. + */ +[uuid(7fcbf4da-d828-4acc-b144-e5435198f727)] +interface nsIRequestContextService : nsISupports +{ + /** + * Get an existing request context from its ID + */ + nsIRequestContext getRequestContext(in unsigned long long id); + /** + * Shorthand to get request context from a load group + */ + nsIRequestContext getRequestContextFromLoadGroup(in nsILoadGroup lg); + + /** + * Create a new request context + */ + nsIRequestContext newRequestContext(); + + /** + * Remove an existing request context from its ID + */ + void removeRequestContext(in unsigned long long id); +}; diff --git a/netwerk/base/nsIRequestObserver.idl b/netwerk/base/nsIRequestObserver.idl new file mode 100644 index 0000000000..772de50d32 --- /dev/null +++ b/netwerk/base/nsIRequestObserver.idl @@ -0,0 +1,37 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +interface nsIRequest; + +/** + * nsIRequestObserver + */ +[scriptable, uuid(fd91e2e0-1481-11d3-9333-00104ba0fd40)] +interface nsIRequestObserver : nsISupports +{ + /** + * Called to signify the beginning of an asynchronous request. + * + * @param aRequest request being observed + * + * An exception thrown from onStartRequest has the side-effect of + * causing the request to be canceled. + */ + void onStartRequest(in nsIRequest aRequest); + + /** + * Called to signify the end of an asynchronous request. This + * call is always preceded by a call to onStartRequest. + * + * @param aRequest request being observed + * @param aStatusCode reason for stopping (NS_OK if completed successfully) + * + * An exception thrown from onStopRequest is generally ignored. + */ + void onStopRequest(in nsIRequest aRequest, + in nsresult aStatusCode); +}; diff --git a/netwerk/base/nsIRequestObserverProxy.idl b/netwerk/base/nsIRequestObserverProxy.idl new file mode 100644 index 0000000000..7b79f53427 --- /dev/null +++ b/netwerk/base/nsIRequestObserverProxy.idl @@ -0,0 +1,31 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsIRequestObserver.idl" + +interface nsIEventTarget; + +/** + * A request observer proxy is used to ship data over to another thread + * specified by the thread's dispatch target. The "true" request observer's + * methods are invoked on the other thread. + * + * This interface only provides the initialization needed after construction. + * Otherwise, these objects are used simply as nsIRequestObserver's. + */ +[scriptable, uuid(c2b06151-1bf8-4eef-aea9-1532f12f5a10)] +interface nsIRequestObserverProxy : nsIRequestObserver +{ + /** + * Initializes an nsIRequestObserverProxy. + * + * @param observer - receives observer notifications on the main thread + * @param context - the context argument that will be passed to OnStopRequest + * and OnStartRequest. This has to be stored permanently on + * initialization because it sometimes can't be + * AddRef/Release'd off-main-thread. + */ + void init(in nsIRequestObserver observer, in nsISupports context); +}; diff --git a/netwerk/base/nsIResumableChannel.idl b/netwerk/base/nsIResumableChannel.idl new file mode 100644 index 0000000000..6737e8bf9d --- /dev/null +++ b/netwerk/base/nsIResumableChannel.idl @@ -0,0 +1,39 @@ +/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +interface nsIStreamListener; + +[scriptable, uuid(4ad136fa-83af-4a22-a76e-503642c0f4a8)] +interface nsIResumableChannel : nsISupports { + /** + * Prepare this channel for resuming. The request will not start until + * asyncOpen or open is called. Calling resumeAt after open or asyncOpen + * has been called has undefined behaviour. + * + * @param startPos the starting offset, in bytes, to use to download + * @param entityID information about the file, to match before obtaining + * the file. Pass an empty string to use anything. + * + * During OnStartRequest, this channel will have a status of + * NS_ERROR_NOT_RESUMABLE if the file cannot be resumed, eg because the + * server doesn't support this. This error may occur even if startPos + * is 0, so that the front end can warn the user. + * Similarly, the status of this channel during OnStartRequest may be + * NS_ERROR_ENTITY_CHANGED, which indicates that the entity has changed, + * as indicated by a changed entityID. + * In both of these cases, no OnDataAvailable will be called, and + * OnStopRequest will immediately follow with the same status code. + */ + void resumeAt(in unsigned long long startPos, + in ACString entityID); + + /** + * The entity id for this URI. Available after OnStartRequest. + * @throw NS_ERROR_NOT_RESUMABLE if this load is not resumable. + */ + readonly attribute ACString entityID; +}; diff --git a/netwerk/base/nsISecCheckWrapChannel.idl b/netwerk/base/nsISecCheckWrapChannel.idl new file mode 100644 index 0000000000..21f4d0c290 --- /dev/null +++ b/netwerk/base/nsISecCheckWrapChannel.idl @@ -0,0 +1,24 @@ +/* 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 "nsISupports.idl" + +interface nsIChannel; + +/** + * nsISecCheckWrapChannel + * Describes an XPCOM component used to wrap channels for performing + * security checks. Channels wrapped inside this class can use + * this interface to query the wrapped inner channel. + */ + +[scriptable, uuid(9446c5d5-c9fb-4a6e-acf9-ca4fc666efe0)] +interface nsISecCheckWrapChannel : nsISupports +{ + /** + * Returns the wrapped channel inside this class. + */ + readonly attribute nsIChannel innerChannel; + +}; diff --git a/netwerk/base/nsISecureBrowserUI.idl b/netwerk/base/nsISecureBrowserUI.idl new file mode 100644 index 0000000000..3984310d93 --- /dev/null +++ b/netwerk/base/nsISecureBrowserUI.idl @@ -0,0 +1,21 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * 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 "nsISupports.idl" + +interface nsITransportSecurityInfo; + +[scriptable, builtinclass, uuid(718c662a-f810-4a80-a6c9-0b1810ecade2)] +interface nsISecureBrowserUI : nsISupports +{ + readonly attribute unsigned long state; + readonly attribute bool isSecureContext; + readonly attribute nsITransportSecurityInfo secInfo; +}; + +%{C++ +#define NS_SECURE_BROWSER_UI_CONTRACTID "@mozilla.org/secure_browser_ui;1" +%} diff --git a/netwerk/base/nsISensitiveInfoHiddenURI.idl b/netwerk/base/nsISensitiveInfoHiddenURI.idl new file mode 100644 index 0000000000..abb3f082b9 --- /dev/null +++ b/netwerk/base/nsISensitiveInfoHiddenURI.idl @@ -0,0 +1,17 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +[scriptable, uuid(a5761968-6e1a-4f2d-8191-ec749602b178)] +interface nsISensitiveInfoHiddenURI : nsISupports +{ + /** + * Returns the spec attribute with sensitive information hidden. This will + * only affect uri with password. The password part of uri will be + * transformed into "****". + */ + AUTF8String getSensitiveInfoHiddenSpec(); +}; diff --git a/netwerk/base/nsISerializationHelper.idl b/netwerk/base/nsISerializationHelper.idl new file mode 100644 index 0000000000..740927f407 --- /dev/null +++ b/netwerk/base/nsISerializationHelper.idl @@ -0,0 +1,29 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +/** + * Simple scriptable serialization helper. Can be used as a service. + */ + +interface nsISerializable; + +[scriptable, uuid(31654c0f-35f3-44c6-b31e-37a11516e6bc)] +interface nsISerializationHelper : nsISupports +{ + /** + * Serialize the object to a base64 string. This string can be later passed + * as an input to deserializeObject method. + */ + ACString serializeToString(in nsISerializable serializable); + + /** + * Takes base64 encoded string that cointains serialization of a single + * object. Most commonly, input is result of previous call to + * serializeToString. + */ + nsISupports deserializeObject(in ACString input); +}; diff --git a/netwerk/base/nsIServerSocket.idl b/netwerk/base/nsIServerSocket.idl new file mode 100644 index 0000000000..61e38602ff --- /dev/null +++ b/netwerk/base/nsIServerSocket.idl @@ -0,0 +1,262 @@ +/* vim:set ts=4 sw=4 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 "nsISupports.idl" + +interface nsIFile; +interface nsIServerSocketListener; +interface nsISocketTransport; + +native PRNetAddr(union PRNetAddr); +[ptr] native PRNetAddrPtr(union PRNetAddr); + +typedef unsigned long nsServerSocketFlag; + +/** + * nsIServerSocket + * + * An interface to a server socket that can accept incoming connections. + */ +[scriptable, uuid(7a9c39cb-a13f-4eef-9bdf-a74301628742)] +interface nsIServerSocket : nsISupports +{ + /** + * @name Server Socket Flags + * These flags define various socket options. + * @{ + */ + /// The server socket will only respond to connections on the + /// local loopback interface. Otherwise, it will accept connections + /// from any interface. To specify a particular network interface, + /// use initWithAddress. + const nsServerSocketFlag LoopbackOnly = 0x00000001; + /// The server socket will not be closed when Gecko is set + /// offline. + const nsServerSocketFlag KeepWhenOffline = 0x00000002; + /** @} */ + + /** + * init + * + * This method initializes a server socket. + * + * @param aPort + * The port of the server socket. Pass -1 to indicate no preference, + * and a port will be selected automatically. + * @param aLoopbackOnly + * If true, the server socket will only respond to connections on the + * local loopback interface. Otherwise, it will accept connections + * from any interface. To specify a particular network interface, + * use initWithAddress. + * @param aBackLog + * The maximum length the queue of pending connections may grow to. + * This parameter may be silently limited by the operating system. + * Pass -1 to use the default value. + */ + void init(in long aPort, + in boolean aLoopbackOnly, + in long aBackLog); + + /** + * the same as init(), but initializes an IPv6 server socket + */ + void initIPv6(in long aPort, + in boolean aLoopbackOnly, + in long aBackLog); + + /** + * initSpecialConnection + * + * This method initializes a server socket and offers the ability to have + * that socket not get terminated if Gecko is set offline. + * + * @param aPort + * The port of the server socket. Pass -1 to indicate no preference, + * and a port will be selected automatically. + * @param aFlags + * Flags for the socket. + * @param aBackLog + * The maximum length the queue of pending connections may grow to. + * This parameter may be silently limited by the operating system. + * Pass -1 to use the default value. + */ + void initSpecialConnection(in long aPort, + in nsServerSocketFlag aFlags, + in long aBackLog); + + + /** + * initWithAddress + * + * This method initializes a server socket, and binds it to a particular + * local address (and hence a particular local network interface). + * + * @param aAddr + * The address to which this server socket should be bound. + * @param aBackLog + * The maximum length the queue of pending connections may grow to. + * This parameter may be silently limited by the operating system. + * Pass -1 to use the default value. + */ + [noscript] void initWithAddress([const] in PRNetAddrPtr aAddr, in long aBackLog); + + /** + * initWithFilename + * + * This method initializes a Unix domain or "local" server socket. Such + * a socket has a name in the filesystem, like an ordinary file. To + * connect, a client supplies the socket's filename, and the usual + * permission checks on socket apply. + * + * This makes Unix domain sockets useful for communication between the + * programs being run by a specific user on a single machine: the + * operating system takes care of authentication, and the user's home + * directory or profile directory provide natural per-user rendezvous + * points. + * + * Since Unix domain sockets are always local to the machine, they are + * not affected by the nsIIOService's 'offline' flag. + * + * The system-level socket API may impose restrictions on the length of + * the filename that are stricter than those of the underlying + * filesystem. If the file name is too long, this returns + * NS_ERROR_FILE_NAME_TOO_LONG. + * + * All components of the path prefix of |aPath| must name directories; + * otherwise, this returns NS_ERROR_FILE_NOT_DIRECTORY. + * + * This call requires execute permission on all directories containing + * the one in which the socket is to be created, and write and execute + * permission on the directory itself. Otherwise, this returns + * NS_ERROR_CONNECTION_REFUSED. + * + * This call creates the socket's directory entry. There must not be + * any existing entry with the given name. If there is, this returns + * NS_ERROR_SOCKET_ADDRESS_IN_USE. + * + * On systems that don't support Unix domain sockets at all, this + * returns NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED. + * + * @param aPath nsIFile + * The file name at which the socket should be created. + * + * @param aPermissions unsigned long + * Unix-style permission bits to be applied to the new socket. + * + * Note about permissions: Linux's unix(7) man page claims that some + * BSD-derived systems ignore permissions on UNIX-domain sockets; + * NetBSD's bind(2) man page agrees, but says it does check now (dated + * 2005). POSIX has required 'connect' to fail if write permission on + * the socket itself is not granted since 2003 (Issue 6). NetBSD says + * that the permissions on the containing directory (execute) have + * always applied, so creating sockets in appropriately protected + * directories should be secure on both old and new systems. + */ + void initWithFilename(in nsIFile aPath, in unsigned long aPermissions, + in long aBacklog); + + /** + * initWithAbstractAddress + * + * This mehtod is a flavor of initWithFilename method. This initializes + * a UNIX domain socket that uses abstract socket address. + * This socket type is only supported on Linux and Android. + * + * On systems that don't support this type's UNIX domain sockets at all, + * this returns NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED. + * + * @param aName + * The abstract socket address which the socket should be created. + * @param aBacklog + * The maximum length the queue of pending connections may grow to. + */ + void initWithAbstractAddress(in AUTF8String aName, + in long aBacklog); + + /** + * close + * + * This method closes a server socket. This does not affect already + * connected client sockets (i.e., the nsISocketTransport instances + * created from this server socket). This will cause the onStopListening + * event to asynchronously fire with a status of NS_BINDING_ABORTED. + */ + void close(); + + /** + * asyncListen + * + * This method puts the server socket in the listening state. It will + * asynchronously listen for and accept client connections. The listener + * will be notified once for each client connection that is accepted. The + * listener's onSocketAccepted method will be called on the same thread + * that called asyncListen (the calling thread must have a nsIEventTarget). + * + * The listener will be passed a reference to an already connected socket + * transport (nsISocketTransport). See below for more details. + * + * @param aListener + * The listener to be notified when client connections are accepted. + */ + void asyncListen(in nsIServerSocketListener aListener); + + /** + * Returns the port of this server socket. + */ + readonly attribute long port; + + /** + * Returns the address to which this server socket is bound. Since a + * server socket may be bound to multiple network devices, this address + * may not necessarily be specific to a single network device. In the + * case of an IP socket, the IP address field would be zerod out to + * indicate a server socket bound to all network devices. Therefore, + * this method cannot be used to determine the IP address of the local + * system. See nsIDNSService::myHostName if this is what you need. + */ + [noscript] PRNetAddr getAddress(); +}; + +/** + * nsIServerSocketListener + * + * This interface is notified whenever a server socket accepts a new connection. + * The transport is in the connected state, and read/write streams can be opened + * using the normal nsITransport API. The address of the client can be found by + * calling the nsISocketTransport::GetAddress method or by inspecting + * nsISocketTransport::GetHost, which returns a string representation of the + * client's IP address (NOTE: this may be an IPv4 or IPv6 string literal). + */ +[scriptable, uuid(836d98ec-fee2-4bde-b609-abd5e966eabd)] +interface nsIServerSocketListener : nsISupports +{ + /** + * onSocketAccepted + * + * This method is called when a client connection is accepted. + * + * @param aServ + * The server socket. + * @param aTransport + * The connected socket transport. + */ + void onSocketAccepted(in nsIServerSocket aServ, + in nsISocketTransport aTransport); + + /** + * onStopListening + * + * This method is called when the listening socket stops for some reason. + * The server socket is effectively dead after this notification. + * + * @param aServ + * The server socket. + * @param aStatus + * The reason why the server socket stopped listening. If the + * server socket was manually closed, then this value will be + * NS_BINDING_ABORTED. + */ + void onStopListening(in nsIServerSocket aServ, in nsresult aStatus); +}; diff --git a/netwerk/base/nsISimpleStreamListener.idl b/netwerk/base/nsISimpleStreamListener.idl new file mode 100644 index 0000000000..99169481f5 --- /dev/null +++ b/netwerk/base/nsISimpleStreamListener.idl @@ -0,0 +1,25 @@ +/* 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 "nsIStreamListener.idl" + +interface nsIOutputStream; + +/** + * A simple stream listener can be used with AsyncRead to supply data to + * a output stream. + */ +[scriptable, uuid(a9b84f6a-0824-4278-bae6-bfca0570a26e)] +interface nsISimpleStreamListener : nsIStreamListener +{ + /** + * Initialize the simple stream listener. + * + * @param aSink data will be read from the channel to this output stream. + * Must implement writeFrom. + * @param aObserver optional stream observer (can be NULL) + */ + void init(in nsIOutputStream aSink, + in nsIRequestObserver aObserver); +}; diff --git a/netwerk/base/nsISocketFilter.idl b/netwerk/base/nsISocketFilter.idl new file mode 100644 index 0000000000..0846fa2eda --- /dev/null +++ b/netwerk/base/nsISocketFilter.idl @@ -0,0 +1,53 @@ +/* -*- Mode: IDL; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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 "nsISupports.idl" +#include "nsINetAddr.idl" + +native NetAddr(mozilla::net::NetAddr); +[ptr] native NetAddrPtr(mozilla::net::NetAddr); + + +/** + * Filters are created and run on the parent, and filter all packets, both + * ingoing and outgoing. The child must specify the name of a recognized filter + * in order to create a socket. + */ +[uuid(afe2c40c-b9b9-4207-b898-e5cde18c6139)] +interface nsISocketFilter : nsISupports +{ + const long SF_INCOMING = 0; + const long SF_OUTGOING = 1; + + bool filterPacket([const]in NetAddrPtr remote_addr, + [const, array, size_is(len)]in uint8_t data, + in unsigned long len, + in long direction); +}; + +/** + * Factory of a specified filter. + */ +[uuid(81ee76c6-4753-4125-9c8c-290ed9ba62fb)] +interface nsISocketFilterHandler : nsISupports +{ + nsISocketFilter newFilter(); +}; + +%{C++ +/** + * Filter handlers are registered with XPCOM under the following CONTRACTID prefix: + */ +#define NS_NETWORK_UDP_SOCKET_FILTER_HANDLER_PREFIX "@mozilla.org/network/udp-filter-handler;1?name=" +#define NS_NETWORK_TCP_SOCKET_FILTER_HANDLER_PREFIX "@mozilla.org/network/tcp-filter-handler;1?name=" + +#define NS_NETWORK_SOCKET_FILTER_HANDLER_STUN_SUFFIX "stun" + +#define NS_STUN_UDP_SOCKET_FILTER_HANDLER_CONTRACTID NS_NETWORK_UDP_SOCKET_FILTER_HANDLER_PREFIX NS_NETWORK_SOCKET_FILTER_HANDLER_STUN_SUFFIX + + +#define NS_STUN_TCP_SOCKET_FILTER_HANDLER_CONTRACTID NS_NETWORK_TCP_SOCKET_FILTER_HANDLER_PREFIX NS_NETWORK_SOCKET_FILTER_HANDLER_STUN_SUFFIX +%} diff --git a/netwerk/base/nsISocketTransport.idl b/netwerk/base/nsISocketTransport.idl new file mode 100644 index 0000000000..aadbdb4c76 --- /dev/null +++ b/netwerk/base/nsISocketTransport.idl @@ -0,0 +1,349 @@ +/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsITransport.idl" +#include "nsIRequest.idl" + +interface nsIInterfaceRequestor; +interface nsINetAddr; + +%{ C++ +#include "mozilla/BasePrincipal.h" +namespace mozilla { +namespace net { +union NetAddr; +class TCPFastOpen; +} +} +%} +native NetAddr(mozilla::net::NetAddr); +[ptr] native NetAddrPtr(mozilla::net::NetAddr); +native OriginAttributes(mozilla::OriginAttributes); +[ref] native const_OriginAttributesRef(const mozilla::OriginAttributes); +[ptr] native TCPFastOpenPtr(mozilla::net::TCPFastOpen); + +/** + * nsISocketTransport + * + * NOTE: Connection setup is triggered by opening an input or output stream, + * it does not start on its own. Completion of the connection setup is + * indicated by a STATUS_CONNECTED_TO notification to the event sink (if set). + * + * NOTE: This is a free-threaded interface, meaning that the methods on + * this interface may be called from any thread. + */ +[scriptable, builtinclass, uuid(79221831-85e2-43a8-8152-05d77d6fde31)] +interface nsISocketTransport : nsITransport +{ + /** + * Get the peer's host for the underlying socket connection. + * For Unix domain sockets, this is a pathname, or the empty string for + * unnamed and abstract socket addresses. + */ + readonly attribute AUTF8String host; + + /** + * Get the port for the underlying socket connection. + * For Unix domain sockets, this is zero. + */ + readonly attribute long port; + + /** + * The origin attributes are used to create sockets. The first party domain + * will eventually be used to isolate OCSP cache and is only non-empty when + * "privacy.firstparty.isolate" is enabled. Setting this is the only way to + * carry origin attributes down to NSPR layers which are final consumers. + * It must be set before the socket transport is built. + */ + [implicit_jscontext, binaryname(ScriptableOriginAttributes)] + attribute jsval originAttributes; + + [noscript, nostdcall, binaryname(GetOriginAttributes)] + OriginAttributes binaryGetOriginAttributes(); + + [noscript, nostdcall, binaryname(SetOriginAttributes)] + void binarySetOriginAttributes(in const_OriginAttributesRef aOriginAttrs); + + /** + * Returns the IP address of the socket connection peer. This + * attribute is defined only once a connection has been established. + */ + [noscript] NetAddr getPeerAddr(); + + /** + * Returns the IP address of the initiating end. This attribute + * is defined only once a connection has been established. + */ + [noscript] NetAddr getSelfAddr(); + + /** + * Bind to a specific local address. + */ + [noscript] void bind(in NetAddrPtr aLocalAddr); + + /** + * Returns a scriptable version of getPeerAddr. This attribute is defined + * only once a connection has been established. + */ + nsINetAddr getScriptablePeerAddr(); + + /** + * Returns a scriptable version of getSelfAddr. This attribute is defined + * only once a connection has been established. + */ + nsINetAddr getScriptableSelfAddr(); + + /** + * Security info object returned from the secure socket provider. This + * object supports nsISSLSocketControl, nsITransportSecurityInfo, and + * possibly other interfaces. + * + * This attribute is only available once the socket is connected. + */ + readonly attribute nsISupports securityInfo; + + /** + * Security notification callbacks passed to the secure socket provider + * via nsISSLSocketControl at socket creation time. + * + * NOTE: this attribute cannot be changed once a stream has been opened. + */ + attribute nsIInterfaceRequestor securityCallbacks; + + /** + * Test if this socket transport is (still) connected. + */ + boolean isAlive(); + + /** + * Socket timeouts in seconds. To specify no timeout, pass UINT32_MAX + * as aValue to setTimeout. The implementation may truncate timeout values + * to a smaller range of values (e.g., 0 to 0xFFFF). + */ + unsigned long getTimeout(in unsigned long aType); + void setTimeout(in unsigned long aType, in unsigned long aValue); + + /** + * Sets the SO_LINGER option with the specified values for the l_onoff and + * l_linger parameters. This applies PR_SockOpt_Linger before PR_Close and + * can be used with a timeout of zero to send an RST packet when closing. + */ + void setLinger(in boolean aPolarity, in short aTimeout); + + /** + * True to set addr and port reuse socket options. + */ + void setReuseAddrPort(in bool reuseAddrPort); + + /** + * Values for the aType parameter passed to get/setTimeout. + */ + const unsigned long TIMEOUT_CONNECT = 0; + const unsigned long TIMEOUT_READ_WRITE = 1; + + /** + * nsITransportEventSink status codes. + * + * Although these look like XPCOM error codes and are passed in an nsresult + * variable, they are *not* error codes. Note that while they *do* overlap + * with existing error codes in Necko, these status codes are confined + * within a very limited context where no error codes may appear, so there + * is no ambiguity. + * + * The values of these status codes must never change. + * + * The status codes appear in near-chronological order (not in numeric + * order). STATUS_RESOLVING may be skipped if the host does not need to be + * resolved. STATUS_WAITING_FOR is an optional status code, which the impl + * of this interface may choose not to generate. + * + * In C++, these constants have a type of uint32_t, so C++ callers must use + * the NS_NET_STATUS_* constants defined below, which have a type of + * nsresult. + */ + const unsigned long STATUS_RESOLVING = 0x804b0003; + const unsigned long STATUS_RESOLVED = 0x804b000b; + const unsigned long STATUS_CONNECTING_TO = 0x804b0007; + const unsigned long STATUS_CONNECTED_TO = 0x804b0004; + const unsigned long STATUS_SENDING_TO = 0x804b0005; + const unsigned long STATUS_WAITING_FOR = 0x804b000a; + const unsigned long STATUS_RECEIVING_FROM = 0x804b0006; + const unsigned long STATUS_TLS_HANDSHAKE_STARTING = 0x804b000c; + const unsigned long STATUS_TLS_HANDSHAKE_ENDED = 0x804b000d; + + /** + * connectionFlags is a bitmask that can be used to modify underlying + * behavior of the socket connection. See the flags below. + */ + attribute unsigned long connectionFlags; + + /** + * Values for the connectionFlags + * + * When making a new connection BYPASS_CACHE will force the Necko DNS + * cache entry to be refreshed with a new call to NSPR if it is set before + * opening the new stream. + */ + const unsigned long BYPASS_CACHE = (1 << 0); + + /** + * When setting this flag, the socket will not apply any + * credentials when establishing a connection. For example, + * an SSL connection would not send any client-certificates + * if this flag is set. + */ + const unsigned long ANONYMOUS_CONNECT = (1 << 1); + + /** + * If set, we will skip all IPv6 addresses the host may have and only + * connect to IPv4 ones. + */ + const unsigned long DISABLE_IPV6 = (1 << 2); + + /** + * If set, indicates that the connection was initiated from a source + * defined as being private in the sense of Private Browsing. Generally, + * there should be no state shared between connections that are private + * and those that are not; it is OK for multiple private connections + * to share state with each other, and it is OK for multiple non-private + * connections to share state with each other. + */ + const unsigned long NO_PERMANENT_STORAGE = (1 << 3); + + /** + * If set, we will skip all IPv4 addresses the host may have and only + * connect to IPv6 ones. + */ + const unsigned long DISABLE_IPV4 = (1 << 4); + + /** + * If set, indicates that the socket should not connect if the hostname + * resolves to an RFC1918 address or IPv6 equivalent. + */ + const unsigned long DISABLE_RFC1918 = (1 << 5); + + /** + * If set, do not use newer protocol features that might have interop problems + * on the Internet. Intended only for use with critical infra like the updater. + * default is false. + */ + const unsigned long BE_CONSERVATIVE = (1 << 6); + + /** + * If set, do not use TRR for resolving the host name. Intended only for + * retries or other scenarios when TRR is deemed likely to have returned a + * wrong adddress. + */ + const unsigned long DISABLE_TRR = (1 << 7); + + /** + * Values for the connectionFlags + * + * When using BYPASS_CACHE, setting this bit will invalidate the existing + * cached entry immediately while the new resolve is being done to avoid + * other users from using stale content in the mean time. + */ + const unsigned long REFRESH_CACHE = (1 << 8); + + /** + * If this flag is set then it means that if connecting the preferred ip + * family has failed, retry with the oppsite one once more. + */ + const unsigned long RETRY_WITH_DIFFERENT_IP_FAMILY = (1 << 9); + + /** + * If we know that a server speaks only tls <1.3 there is no need to try + * to use ech. + */ + const unsigned long DONT_TRY_ECH = (1 << 10); + + /** + * These two bits encode the TRR mode of the request. + * Use the static helper methods convert between the TRR mode and flags. + */ + const unsigned long TRR_MODE_FLAGS = (1 << 11) | (1 << 12); + +%{C++ + + static uint32_t GetFlagsFromTRRMode(nsIRequest::TRRMode aMode) { + return static_cast<uint32_t>(aMode) << 11; + } + + static nsIRequest::TRRMode GetTRRModeFromFlags(uint32_t aFlags) { + return static_cast<nsIRequest::TRRMode>((aFlags & TRR_MODE_FLAGS) >> 11); + } +%} + + /** + * If set, we will use IP hint addresses to connect to the host. + */ + const unsigned long USE_IP_HINT_ADDRESS = (1 << 13); + + /** + * An opaque flags for non-standard behavior of the TLS system. + * It is unlikely this will need to be set outside of telemetry studies + * relating to the TLS implementation. + */ + attribute unsigned long tlsFlags; + + /** + * Socket QoS/ToS markings. Valid values are IPTOS_DSCP_AFxx or + * IPTOS_CLASS_CSx (or IPTOS_DSCP_EF, but currently no supported + * services require expedited-forwarding). + * Not setting this value will leave the socket with the default + * ToS value, which on most systems if IPTOS_CLASS_CS0 (formerly + * IPTOS_PREC_ROUTINE). + */ + attribute octet QoSBits; + + /** + * TCP send and receive buffer sizes. A value of 0 means OS level + * auto-tuning is in effect. + */ + attribute unsigned long recvBufferSize; + attribute unsigned long sendBufferSize; + + /** + * TCP keepalive configuration (support varies by platform). + * Note that the attribute as well as the setter can only accessed + * in the socket thread. + */ + attribute boolean keepaliveEnabled; + void setKeepaliveVals(in long keepaliveIdleTime, + in long keepaliveRetryInterval); + + [noscript] void setFastOpenCallback(in TCPFastOpenPtr aFastOpen); + + readonly attribute nsresult firstRetryError; + + /** + * If true, this socket transport has found out the prefered family + * according it's connection flags could not be used to establish + * connections any more. Hence, the preference should be reset. + */ + readonly attribute boolean resetIPFamilyPreference; + + /** + * This attribute holds information whether echConfig has been used. + * The value is set after PR_Connect is called. + */ + readonly attribute boolean echConfigUsed; + + /** + * Called to set the echConfig to the securityInfo object. + */ + void setEchConfig(in ACString echConfig); + + /** + * IP address resolved using TRR. + */ + bool resolvedByTRR(); + + /** + * Indicate whether this socket is created from a private window. If yes, + * this socket will be closed when the last private window is closed. + */ + [noscript] void setIsPrivate(in boolean isPrivate); +}; diff --git a/netwerk/base/nsISocketTransportService.idl b/netwerk/base/nsISocketTransportService.idl new file mode 100644 index 0000000000..4de6655880 --- /dev/null +++ b/netwerk/base/nsISocketTransportService.idl @@ -0,0 +1,157 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +interface nsIFile; +interface nsISocketTransport; +interface nsIProxyInfo; +interface nsIRunnable; + +%{C++ +class nsASocketHandler; +struct PRFileDesc; +%} + +[ptr] native PRFileDescPtr(PRFileDesc); +[ptr] native nsASocketHandlerPtr(nsASocketHandler); + +[scriptable, function, uuid(338947df-2f3b-4d24-9ce4-ecf161c1b7df)] +interface nsISTSShutdownObserver : nsISupports { + + /** + * Observe will be called when the SocketTransportService is shutting down, + * before threads are stopped. + */ + void observe(); +}; + +[builtinclass, scriptable, uuid(ad56b25f-e6bb-4db3-9f7b-5b7db33fd2b1)] +interface nsISocketTransportService : nsISupports +{ + /** + * Creates a transport for a specified host and port. + * + * @param aSocketTypes + * array of socket type strings. Empty array if using default + * socket type. + * @param aHost + * specifies the target hostname or IP address literal of the peer + * for this socket. + * @param aPort + * specifies the target port of the peer for this socket. + * @param aProxyInfo + * specifies the transport-layer proxy type to use. null if no + * proxy. used for communicating information about proxies like + * SOCKS (which are transparent to upper protocols). + * + * @see nsIProxiedProtocolHandler + * @see nsIProtocolProxyService::GetProxyInfo + * + * NOTE: this function can be called from any thread + */ + nsISocketTransport createTransport(in Array<ACString> aSocketTypes, + in AUTF8String aHost, + in long aPort, + in nsIProxyInfo aProxyInfo); + + /** + * Create a transport built on a Unix domain socket, connecting to the + * given filename. + * + * Since Unix domain sockets are always local to the machine, they are + * not affected by the nsIIOService's 'offline' flag. + * + * On systems that don't support Unix domain sockets at all, this + * returns NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED. + * + * The system-level socket API may impose restrictions on the length of + * the filename that are stricter than those of the underlying + * filesystem. If the file name is too long, this returns + * NS_ERROR_FILE_NAME_TOO_LONG. + * + * The |aPath| parameter must specify an existing directory entry. + * Otherwise, this returns NS_ERROR_FILE_NOT_FOUND. + * + * The program must have search permission on all components of the + * path prefix of |aPath|, and read and write permission on |aPath| + * itself. Without such permission, this returns + * NS_ERROR_CONNECTION_REFUSED. + * + * The |aPath| parameter must refer to a unix-domain socket. Otherwise, + * this returns NS_ERROR_CONNECTION_REFUSED. (POSIX specifies + * ECONNREFUSED when "the target address was not listening for + * connections", and this is what Linux returns.) + * + * @param aPath + * The file name of the Unix domain socket to which we should + * connect. + */ + nsISocketTransport createUnixDomainTransport(in nsIFile aPath); + + /** + * Create a transport built on a Unix domain socket that uses abstract + * address name. + * + * If abstract socket address isn't supported on System, this returns + * NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED. + * + * @param aName + * The name of abstract socket adress of the Unix domain socket to + * which we should connect. + */ + nsISocketTransport + createUnixDomainAbstractAddressTransport(in ACString aName); + + /** + * Adds a new socket to the list of controlled sockets. + * + * This will fail with the error code NS_ERROR_NOT_AVAILABLE if the maximum + * number of sockets is already reached. + * In this case, the notifyWhenCanAttachSocket method should be used. + * + * @param aFd + * Open file descriptor of the socket to control. + * @param aHandler + * Socket handler that will receive notifications when the socket is + * ready or detached. + * + * NOTE: this function may only be called from an event dispatch on the + * socket thread. + */ + [noscript] void attachSocket(in PRFileDescPtr aFd, + in nsASocketHandlerPtr aHandler); + + /** + * if the number of sockets reaches the limit, then consumers can be + * notified when the number of sockets becomes less than the limit. the + * notification is asynchronous, delivered via the given nsIRunnable + * instance on the socket transport thread. + * + * @param aEvent + * Event that will receive the notification when a new socket can + * be attached + * + * NOTE: this function may only be called from an event dispatch on the + * socket thread. + */ + [noscript] void notifyWhenCanAttachSocket(in nsIRunnable aEvent); + + [noscript] void addShutdownObserver(in nsISTSShutdownObserver aObserver); + [noscript] void removeShutdownObserver(in nsISTSShutdownObserver aObserver); +}; + +[builtinclass, scriptable, uuid(c5204623-5b58-4a16-8b2e-67c34dd02e3f)] +interface nsIRoutedSocketTransportService : nsISocketTransportService +{ + // use this instead of createTransport when you have a transport + // that distinguishes between origin and route (aka connection) + nsISocketTransport createRoutedTransport(in Array<ACString> aSocketTypes, + in AUTF8String aHost, // origin + in long aPort, // origin + in AUTF8String aHostRoute, + in long aPortRoute, + in nsIProxyInfo aProxyInfo); +}; diff --git a/netwerk/base/nsISpeculativeConnect.idl b/netwerk/base/nsISpeculativeConnect.idl new file mode 100644 index 0000000000..fd53520ef3 --- /dev/null +++ b/netwerk/base/nsISpeculativeConnect.idl @@ -0,0 +1,71 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +interface nsIPrincipal; +interface nsIURI; +interface nsIInterfaceRequestor; + +[scriptable, uuid(d74a17ac-5b8a-4824-a309-b1f04a3c4aed)] +interface nsISpeculativeConnect : nsISupports +{ + /** + * Called as a hint to indicate a new transaction for the URI is likely coming + * soon. The implementer may use this information to start a TCP + * and/or SSL level handshake for that resource immediately so that it is + * ready and/or progressed when the transaction is actually submitted. + * + * No obligation is taken on by the implementer, nor is the submitter obligated + * to actually open the new channel. + * + * @param aURI the URI of the hinted transaction + * @param aPrincipal the principal that will be used for opening the + * channel of the hinted transaction. + * @param aCallbacks any security callbacks for use with SSL for interfaces. + * May be null. + * + */ + void speculativeConnect(in nsIURI aURI, + in nsIPrincipal aPrincipal, + in nsIInterfaceRequestor aCallbacks); + + void speculativeAnonymousConnect(in nsIURI aURI, + in nsIPrincipal aPrincipal, + in nsIInterfaceRequestor aCallbacks); +}; + +/** + * This is used to override the default values for various values (documented + * inline) to determine whether or not to actually make a speculative + * connection. + */ +[builtinclass, uuid(1040ebe3-6ed1-45a6-8587-995e082518d7)] +interface nsISpeculativeConnectionOverrider : nsISupports +{ + /** + * Used to determine the maximum number of unused speculative connections + * we will have open for a host at any one time + */ + [infallible] readonly attribute unsigned long parallelSpeculativeConnectLimit; + + /** + * Used to determine if we will ignore the existence of any currently idle + * connections when we decide whether or not to make a speculative + * connection. + */ + [infallible] readonly attribute boolean ignoreIdle; + + /* + * Used by the Predictor to gather telemetry data on speculative connection + * usage. + */ + [infallible] readonly attribute boolean isFromPredictor; + + /** + * by default speculative connections are not made to RFC 1918 addresses + */ + [infallible] readonly attribute boolean allow1918; +}; diff --git a/netwerk/base/nsIStandardURL.idl b/netwerk/base/nsIStandardURL.idl new file mode 100644 index 0000000000..dae8ecc13c --- /dev/null +++ b/netwerk/base/nsIStandardURL.idl @@ -0,0 +1,85 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +interface nsIURI; +interface nsIURIMutator; + +/** + * nsIStandardURL defines the interface to an URL with the standard + * file path format common to protocols like http, ftp, and file. + * It supports initialization from a relative path and provides + * some customization on how URLs are normalized. + */ +[scriptable, builtinclass, uuid(babd6cca-ebe7-4329-967c-d6b9e33caa81)] +interface nsIStandardURL : nsISupports +{ + /** + * blah:foo/bar => blah://foo/bar + * blah:/foo/bar => blah:///foo/bar + * blah://foo/bar => blah://foo/bar + * blah:///foo/bar => blah:///foo/bar + */ + const unsigned long URLTYPE_STANDARD = 1; + + /** + * blah:foo/bar => blah://foo/bar + * blah:/foo/bar => blah://foo/bar + * blah://foo/bar => blah://foo/bar + * blah:///foo/bar => blah://foo/bar + */ + const unsigned long URLTYPE_AUTHORITY = 2; + + /** + * blah:foo/bar => blah:///foo/bar + * blah:/foo/bar => blah:///foo/bar + * blah://foo/bar => blah://foo/bar + * blah:///foo/bar => blah:///foo/bar + */ + const unsigned long URLTYPE_NO_AUTHORITY = 3; +}; + +[scriptable, builtinclass, uuid(fc894e98-23a1-43cd-a7fe-72876f8ea2ee)] +interface nsIStandardURLMutator : nsISupports +{ + /** + * Initialize a standard URL. + * + * @param aUrlType - one of the URLTYPE_ flags listed above. + * @param aDefaultPort - if the port parsed from the URL string matches + * this port, then the port will be removed from the + * canonical form of the URL. + * @param aSpec - URL string. + * @param aOriginCharset - the charset from which this URI string + * originated. this corresponds to the charset + * that should be used when communicating this + * URI to an origin server, for example. if + * null, then provide aBaseURI implements this + * interface, the origin charset of aBaseURI will + * be assumed, otherwise defaulting to UTF-8 (i.e., + * no charset transformation from aSpec). + * @param aBaseURI - if null, aSpec must specify an absolute URI. + * otherwise, aSpec will be resolved relative + * to aBaseURI. + */ + nsIURIMutator init(in unsigned long aUrlType, + in long aDefaultPort, + in AUTF8String aSpec, + in string aOriginCharset, + in nsIURI aBaseURI); + + /** + * Set the default port. + * + * Note: If this object is already using its default port (i.e. if it has + * mPort == -1), then it will now implicitly be using the new default port. + * + * @param aNewDefaultPort - if the URI has (or is later given) a port that + * matches this default, then we won't include a + * port number in the canonical form of the URL. + */ + nsIURIMutator setDefaultPort(in long aNewDefaultPort); +}; diff --git a/netwerk/base/nsIStreamListener.idl b/netwerk/base/nsIStreamListener.idl new file mode 100644 index 0000000000..68ade60cd1 --- /dev/null +++ b/netwerk/base/nsIStreamListener.idl @@ -0,0 +1,38 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsIRequestObserver.idl" + +interface nsIInputStream; + +/** + * nsIStreamListener + */ +[scriptable, uuid(3b4c8a77-76ba-4610-b316-678c73a3b88c)] +interface nsIStreamListener : nsIRequestObserver +{ + /** + * Called when the next chunk of data (corresponding to the request) may + * be read without blocking the calling thread. The onDataAvailable impl + * must read exactly |aCount| bytes of data before returning. + * + * @param aRequest request corresponding to the source of the data + * @param aInputStream input stream containing the data chunk + * @param aOffset + * Number of bytes that were sent in previous onDataAvailable calls + * for this request. In other words, the sum of all previous count + * parameters. + * @param aCount number of bytes available in the stream + * + * NOTE: The aInputStream parameter must implement readSegments. + * + * An exception thrown from onDataAvailable has the side-effect of + * causing the request to be canceled. + */ + void onDataAvailable(in nsIRequest aRequest, + in nsIInputStream aInputStream, + in unsigned long long aOffset, + in unsigned long aCount); +}; diff --git a/netwerk/base/nsIStreamListenerTee.idl b/netwerk/base/nsIStreamListenerTee.idl new file mode 100644 index 0000000000..d51bdf3c46 --- /dev/null +++ b/netwerk/base/nsIStreamListenerTee.idl @@ -0,0 +1,50 @@ +/* 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 "nsIStreamListener.idl" + +interface nsIOutputStream; +interface nsIRequestObserver; +interface nsIEventTarget; + +/** + * As data "flows" into a stream listener tee, it is copied to the output stream + * and then forwarded to the real listener. + */ +[scriptable, uuid(62b27fc1-6e8c-4225-8ad0-b9d44252973a)] +interface nsIStreamListenerTee : nsIStreamListener +{ + /** + * Initalize the tee. + * + * @param listener + * the original listener the tee will propagate onStartRequest, + * onDataAvailable and onStopRequest notifications to, exceptions from + * the listener will be propagated back to the channel + * @param sink + * the stream the data coming from the channel will be written to, + * should be blocking + * @param requestObserver + * optional parameter, listener that gets only onStartRequest and + * onStopRequest notifications; exceptions threw within this optional + * observer are also propagated to the channel, but exceptions from + * the original listener (listener parameter) are privileged + */ + void init(in nsIStreamListener listener, + in nsIOutputStream sink, + [optional] in nsIRequestObserver requestObserver); + + /** + * Initalize the tee like above, but with the extra parameter to make it + * possible to copy the output asynchronously + * @param anEventTarget + * if set, this event-target is used to copy data to the output stream, + * giving an asynchronous tee + */ + void initAsync(in nsIStreamListener listener, + in nsIEventTarget eventTarget, + in nsIOutputStream sink, + [optional] in nsIRequestObserver requestObserver); + +}; diff --git a/netwerk/base/nsIStreamLoader.idl b/netwerk/base/nsIStreamLoader.idl new file mode 100644 index 0000000000..274a07e9d0 --- /dev/null +++ b/netwerk/base/nsIStreamLoader.idl @@ -0,0 +1,77 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "nsIStreamListener.idl" + +interface nsIRequest; +interface nsIStreamLoader; + +[scriptable, uuid(359F7990-D4E9-11d3-A1A5-0050041CAF44)] +interface nsIStreamLoaderObserver : nsISupports +{ + /** + * Called when the entire stream has been loaded. + * + * @param loader the stream loader that loaded the stream. + * @param ctxt the context parameter of the underlying channel + * @param status the status of the underlying channel + * @param resultLength the length of the data loaded + * @param result the data + * + * This method will always be called asynchronously by the + * nsIStreamLoader involved, on the thread that called the + * loader's init() method. + * + * If the observer wants to take over responsibility for the + * data buffer (result), it returns NS_SUCCESS_ADOPTED_DATA + * in place of NS_OK as its success code. The loader will then + * "forget" about the data and not free() it after + * onStreamComplete() returns; observer must call free() + * when the data is no longer required. + */ + void onStreamComplete(in nsIStreamLoader loader, + in nsISupports ctxt, + in nsresult status, + in unsigned long resultLength, + [const,array,size_is(resultLength)] in octet result); +}; + +/** + * Asynchronously loads a channel into a memory buffer. + * + * To use this interface, first call init() with a nsIStreamLoaderObserver + * that will be notified when the data has been loaded. Then call asyncOpen() + * on the channel with the nsIStreamLoader as the listener. The context + * argument in the asyncOpen() call will be passed to the onStreamComplete() + * callback. + * + * XXX define behaviour for sizes >4 GB + */ +[scriptable, uuid(323bcff1-7513-4e1f-a541-1c9213c2ed1b)] +interface nsIStreamLoader : nsIStreamListener +{ + /** + * Initialize this stream loader, and start loading the data. + * + * @param aStreamObserver + * An observer that will be notified when the data is complete. + * @param aRequestObserver + * An optional observer that will be notified when the request + * has started or stopped. + */ + void init(in nsIStreamLoaderObserver aStreamObserver, + [optional] in nsIRequestObserver aRequestObserver); + + /** + * Gets the number of bytes read so far. + */ + readonly attribute unsigned long numBytesRead; + + /** + * Gets the request that loaded this file. + * null after the request has finished loading. + */ + readonly attribute nsIRequest request; +}; diff --git a/netwerk/base/nsIStreamTransportService.idl b/netwerk/base/nsIStreamTransportService.idl new file mode 100644 index 0000000000..e3ac6e6b18 --- /dev/null +++ b/netwerk/base/nsIStreamTransportService.idl @@ -0,0 +1,49 @@ +/* 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 "nsISupports.idl" + +interface nsITransport; +interface nsIInputStream; +interface nsIOutputStream; +interface nsIInputAvailableCallback; + +/** + * This service read/writes a stream on a background thread. + * + * Note: instead of using this interface, probably you want to use + * NS_MakeAsyncNonBlockingInputStream. + * + * Use this service to transform any blocking stream (e.g., file stream) + * into a fully asynchronous stream that can be read/written without + * blocking the main thread. + */ +[builtinclass, scriptable, uuid(5e0adf7d-9785-45c3-a193-04f25a75da8f)] +interface nsIStreamTransportService : nsISupports +{ + /** + * CreateInputTransport + * + * @param aStream + * The input stream that will be read on a background thread. + * This stream must implement "blocking" stream semantics. + * @param aCloseWhenDone + * Specify this flag to have the input stream closed once its + * contents have been completely read. + * + * @return nsITransport instance. + */ + nsITransport createInputTransport(in nsIInputStream aStream, + in boolean aCloseWhenDone); + + void InputAvailable(in nsIInputStream aStream, + in nsIInputAvailableCallback aCallback); +}; + +[builtinclass, uuid(ff2da731-44d0-4dd9-8236-c99387fec721)] +interface nsIInputAvailableCallback : nsISupports +{ + void onInputAvailableComplete(in unsigned long long available, + in nsresult available_return_code); +}; diff --git a/netwerk/base/nsISyncStreamListener.idl b/netwerk/base/nsISyncStreamListener.idl new file mode 100644 index 0000000000..9a46dda787 --- /dev/null +++ b/netwerk/base/nsISyncStreamListener.idl @@ -0,0 +1,19 @@ +/* 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 "nsIStreamListener.idl" + +[scriptable, uuid(7e1aa658-6e3f-4521-9946-9685a169f764)] +interface nsISyncStreamListener : nsIStreamListener +{ + /** + * Returns an input stream that when read will fetch data delivered to the + * sync stream listener. The nsIInputStream implementation will wait for + * OnDataAvailable events before returning from Read. + * + * NOTE: Reading from the returned nsIInputStream may spin the current + * thread's event queue, which could result in any event being processed. + */ + readonly attribute nsIInputStream inputStream; +}; diff --git a/netwerk/base/nsISystemProxySettings.idl b/netwerk/base/nsISystemProxySettings.idl new file mode 100644 index 0000000000..9cd561fb64 --- /dev/null +++ b/netwerk/base/nsISystemProxySettings.idl @@ -0,0 +1,42 @@ +/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +/** + * This interface allows the proxy code to use platform-specific proxy + * settings when the proxy preference is set to "automatic discovery". This service + * acts like a PAC parser to netwerk, but it will actually read the system settings and + * either return the proper proxy data from the autoconfig URL specified in the system proxy, + * or generate proxy data based on the system's manual proxy settings. + */ +[scriptable, uuid(971591cd-277e-409a-bbf6-0a79879cd307)] +interface nsISystemProxySettings : nsISupports +{ + /** + * Whether or not it is appropriate to execute getProxyForURI off the main thread. + * If that method can block (e.g. for WPAD as windows does) then it must be + * not mainThreadOnly to avoid creating main thread jank. The main thread only option is + * provided for implementations that do not block but use other main thread only + * functions such as dbus. + */ + readonly attribute bool mainThreadOnly; + + /** + * If non-empty, use this PAC file. If empty, call getProxyForURI instead. + */ + readonly attribute AUTF8String PACURI; + + /** + * See ProxyAutoConfig::getProxyForURI; this function behaves similarly except + * a more relaxed return string is allowed that includes full urls instead of just + * host:port syntax. e.g. "PROXY http://www.foo.com:8080" instead of + * "PROXY www.foo.com:8080" + */ + AUTF8String getProxyForURI(in AUTF8String testSpec, + in AUTF8String testScheme, + in AUTF8String testHost, + in int32_t testPort); +}; diff --git a/netwerk/base/nsITLSServerSocket.idl b/netwerk/base/nsITLSServerSocket.idl new file mode 100644 index 0000000000..e944f23af7 --- /dev/null +++ b/netwerk/base/nsITLSServerSocket.idl @@ -0,0 +1,183 @@ +/* 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 "nsIServerSocket.idl" + +interface nsIX509Cert; +interface nsITLSServerSecurityObserver; +interface nsISocketTransport; + +[scriptable, uuid(cc2c30f9-cfaa-4b8a-bd44-c24881981b74)] +interface nsITLSServerSocket : nsIServerSocket +{ + /** + * serverCert + * + * The server's certificate that is presented to the client during the TLS + * handshake. This is required to be set before calling |asyncListen|. + */ + attribute nsIX509Cert serverCert; + + /** + * setSessionTickets + * + * Whether the server should support session tickets. Defaults to true. This + * should be set before calling |asyncListen| if you wish to change the + * default. + */ + void setSessionTickets(in boolean aSessionTickets); + + /** + * Values for setRequestClientCertificate + */ + // Never request + const unsigned long REQUEST_NEVER = 0; + // Request (but do not require) during the first handshake only + const unsigned long REQUEST_FIRST_HANDSHAKE = 1; + // Request (but do not require) during each handshake + const unsigned long REQUEST_ALWAYS = 2; + // Require during the first handshake only + const unsigned long REQUIRE_FIRST_HANDSHAKE = 3; + // Require during each handshake + const unsigned long REQUIRE_ALWAYS = 4; + + /** + * setRequestClientCertificate + * + * Whether the server should request and/or require a client auth certificate + * from the client. Defaults to REQUEST_NEVER. See the possible options + * above. This should be set before calling |asyncListen| if you wish to + * change the default. + */ + void setRequestClientCertificate(in unsigned long aRequestClientCert); + + /** + * setVersionRange + * + * The server's TLS versions that is used by the TLS handshake. + * This is required to be set before calling |asyncListen|. + * + * aMinVersion and aMaxVersion is a TLS version value from + * |nsITLSClientStatus| constants. + */ + void setVersionRange(in unsigned short aMinVersion, + in unsigned short aMaxVersion); +}; + +/** + * Security summary for a given TLS client connection being handled by a + * |nsITLSServerSocket| server. + * + * This is accessible through the security info object on the transport, which + * will be an instance of |nsITLSServerConnectionInfo| (see below). + * + * The values of these attributes are available once the |onHandshakeDone| + * method of the security observer has been called (see + * |nsITLSServerSecurityObserver| below). + */ +[scriptable, uuid(19668ea4-e5ad-4182-9698-7e890d48f327)] +interface nsITLSClientStatus : nsISupports +{ + /** + * peerCert + * + * The client's certificate, if one was requested via |requestCertificate| + * above and supplied by the client. + */ + readonly attribute nsIX509Cert peerCert; + + /** + * Values for tlsVersionUsed, as defined by TLS + */ + const short SSL_VERSION_3 = 0x0300; + const short TLS_VERSION_1 = 0x0301; + const short TLS_VERSION_1_1 = 0x0302; + const short TLS_VERSION_1_2 = 0x0303; + const short TLS_VERSION_1_3 = 0x0304; + const short TLS_VERSION_UNKNOWN = -1; + + /** + * tlsVersionUsed + * + * The version of TLS used by the connection. See values above. + */ + readonly attribute short tlsVersionUsed; + + /** + * cipherName + * + * Name of the cipher suite used, such as + * "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256". + * See security/nss/lib/ssl/sslinfo.c for the possible values. + */ + readonly attribute ACString cipherName; + + /** + * keyLength + * + * The "effective" key size of the symmetric key in bits. + */ + readonly attribute unsigned long keyLength; + + /** + * macLength + * + * The size of the MAC in bits. + */ + readonly attribute unsigned long macLength; +}; + +/** + * Connection info for a given TLS client connection being handled by a + * |nsITLSServerSocket| server. This object is thread-safe. + * + * This is exposed as the security info object on the transport, so it can be + * accessed via |transport.securityInfo|. + * + * This interface is available by the time the |onSocketAttached| is called, + * which is the first time the TLS server consumer is notified of a new client. + */ +[scriptable, uuid(8a93f5d5-eddd-4c62-a4bd-bfd297653184)] +interface nsITLSServerConnectionInfo : nsISupports +{ + /** + * setSecurityObserver + * + * Set the security observer to be notified when the TLS handshake has + * completed. + */ + void setSecurityObserver(in nsITLSServerSecurityObserver observer); + + /** + * serverSocket + * + * The nsITLSServerSocket instance that accepted this client connection. + */ + readonly attribute nsITLSServerSocket serverSocket; + + /** + * status + * + * Security summary for this TLS client connection. Note that the values of + * this interface are not available until the TLS handshake has completed. + * See |nsITLSClientStatus| above for more details. + */ + readonly attribute nsITLSClientStatus status; +}; + +[scriptable, uuid(1f62e1ae-e546-4a38-8917-d428472ed736)] +interface nsITLSServerSecurityObserver : nsISupports +{ + /** + * onHandsakeDone + * + * This method is called once the TLS handshake is completed. This takes + * place after |onSocketAccepted| has been called, which typically opens the + * streams to keep things moving along. It's important to be aware that the + * handshake has not completed at the point that |onSocketAccepted| is called, + * so no security verification can be done until this method is called. + */ + void onHandshakeDone(in nsITLSServerSocket aServer, + in nsITLSClientStatus aStatus); +}; diff --git a/netwerk/base/nsIThreadRetargetableRequest.idl b/netwerk/base/nsIThreadRetargetableRequest.idl new file mode 100644 index 0000000000..ac5a6444ba --- /dev/null +++ b/netwerk/base/nsIThreadRetargetableRequest.idl @@ -0,0 +1,43 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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 "nsISupports.idl" + +interface nsIEventTarget; + +/** + * nsIThreadRetargetableRequest + * + * Should be implemented by requests that support retargeting delivery of + * data off the main thread. + */ +[uuid(27b84c48-5a73-4ba4-a8a4-8b5e649a145e)] +interface nsIThreadRetargetableRequest : nsISupports +{ + /** + * Called to retarget delivery of OnDataAvailable to another thread. Should + * only be called before AsyncOpen for nsIWebsocketChannels, or during + * OnStartRequest for nsIChannels. + * Note: For nsIChannels, OnStartRequest and OnStopRequest will still be + * delivered on the main thread. + * + * @param aNewTarget New event target, e.g. thread or threadpool. + * + * Note: no return value is given. If the retargeting cannot be handled, + * normal delivery to the main thread will continue. As such, listeners + * should be ready to deal with OnDataAvailable on either the main thread or + * the new target thread. + */ + void retargetDeliveryTo(in nsIEventTarget aNewTarget); + + /** + * Returns the event target where OnDataAvailable events will be dispatched. + * + * This is only valid after OnStartRequest has been called. Any time before + * that point, the value may be changed by `retargetDeliveryTo` calls. + */ + readonly attribute nsIEventTarget deliveryTarget; +}; diff --git a/netwerk/base/nsIThreadRetargetableStreamListener.idl b/netwerk/base/nsIThreadRetargetableStreamListener.idl new file mode 100644 index 0000000000..428807a156 --- /dev/null +++ b/netwerk/base/nsIThreadRetargetableStreamListener.idl @@ -0,0 +1,33 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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 "nsISupports.idl" + +/** + * nsIThreadRetargetableStreamListener + * + * To be used by classes which implement nsIStreamListener and whose + * OnDataAvailable callback may be retargeted for delivery off the main thread. + */ +[uuid(fb2304b8-f82f-4433-af68-d874a2ebbdc1)] +interface nsIThreadRetargetableStreamListener : nsISupports +{ + /** + * Checks this listener and any next listeners it may have to verify that + * they can receive OnDataAvailable off the main thread. It is the + * responsibility of the implementing class to decide on the criteria to + * determine if retargeted delivery of these methods is possible, but it must + * check any and all nsIStreamListener objects that might be called in the + * listener chain. + * + * An exception should be thrown if a listener in the chain does not + * support retargeted delivery, i.e. if the next listener does not implement + * nsIThreadRetargetableStreamListener, or a call to its checkListenerChain() + * fails. + */ + void checkListenerChain(); +}; + diff --git a/netwerk/base/nsIThrottledInputChannel.idl b/netwerk/base/nsIThrottledInputChannel.idl new file mode 100644 index 0000000000..ae8d7321db --- /dev/null +++ b/netwerk/base/nsIThrottledInputChannel.idl @@ -0,0 +1,87 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +interface nsIInputStream; +interface nsIAsyncInputStream; + +/** + * An instance of this interface can be used to throttle the uploads + * of a group of associated channels. + */ +[scriptable, uuid(6b4b96fe-3c67-4587-af7b-58b6b17da411)] +interface nsIInputChannelThrottleQueue : nsISupports +{ + /** + * Initialize this object with the mean and maximum bytes per + * second that will be allowed. Neither value may be zero, and + * the maximum must not be less than the mean. + * + * @param aMeanBytesPerSecond + * Mean number of bytes per second. + * @param aMaxBytesPerSecond + * Maximum number of bytes per second. + */ + void init(in unsigned long aMeanBytesPerSecond, in unsigned long aMaxBytesPerSecond); + + /** + * Internal use only. Get the values set by init method. + */ + [noscript] readonly attribute unsigned long meanBytesPerSecond; + [noscript] readonly attribute unsigned long maxBytesPerSecond; + + + /** + * Return the number of bytes that are available to the caller in + * this time slice. + * + * @param aRemaining + * The number of bytes available to be processed + * @return the number of bytes allowed to be processed during this + * time slice; this will never be greater than aRemaining. + */ + unsigned long available(in unsigned long aRemaining); + + /** + * Record a successful read. + * + * @param aBytesRead + * The number of bytes actually read. + */ + void recordRead(in unsigned long aBytesRead); + + /** + * Return the number of bytes allowed through this queue. This is + * the sum of all the values passed to recordRead. This method is + * primarily useful for testing. + */ + unsigned long long bytesProcessed(); + + /** + * Wrap the given input stream in a new input stream which + * throttles the incoming data. + * + * @param aInputStream the input stream to wrap + * @return a new input stream that throttles the data. + */ + nsIAsyncInputStream wrapStream(in nsIInputStream aInputStream); +}; + +/** + * A throttled input channel can be managed by an + * nsIInputChannelThrottleQueue to limit how much data is sent during + * a given time slice. + */ +[scriptable, uuid(0a32a100-c031-45b6-9e8b-0444c7d4a143)] +interface nsIThrottledInputChannel : nsISupports +{ + /** + * The queue that manages this channel. Multiple channels can + * share a single queue. A null value means that no throttling + * will be done. + */ + attribute nsIInputChannelThrottleQueue throttleQueue; +}; diff --git a/netwerk/base/nsITimedChannel.idl b/netwerk/base/nsITimedChannel.idl new file mode 100644 index 0000000000..48efff5355 --- /dev/null +++ b/netwerk/base/nsITimedChannel.idl @@ -0,0 +1,122 @@ +/* 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 "nsISupports.idl" +interface nsIArray; +interface nsIPrincipal; +%{C++ +namespace mozilla { +class TimeStamp; +} +#include "nsTArrayForwardDeclare.h" +#include "nsCOMPtr.h" +%} + +native TimeStamp(mozilla::TimeStamp); + +[scriptable, uuid(c2d9e95b-9cc9-4f47-9ef6-1de0cf7ebc75)] +interface nsIServerTiming : nsISupports { + [must_use] readonly attribute ACString name; + [must_use] readonly attribute double duration; + [must_use] readonly attribute ACString description; +}; + +[ref] native nsServerTimingArrayRef(nsTArray<nsCOMPtr<nsIServerTiming>>); + +// All properties return zero if the value is not available +[scriptable, uuid(ca63784d-959c-4c3a-9a59-234a2a520de0)] +interface nsITimedChannel : nsISupports { + // Set this attribute to true to enable collection of timing data. + // channelCreationTime will be available even with this attribute set to + // false. + attribute boolean timingEnabled; + + // The number of redirects + attribute uint8_t redirectCount; + attribute uint8_t internalRedirectCount; + + // These properties should only be written externally when they must be + // propagated across an internal redirect. For example, when a service + // worker interception falls back to network we need to copy the original + // timing values to the new nsHttpChannel. + [noscript] attribute TimeStamp channelCreation; + [noscript] attribute TimeStamp asyncOpen; + + // The following are only set when the request is intercepted by a service + // worker no matter the response is synthesized. + [noscript] attribute TimeStamp launchServiceWorkerStart; + [noscript] attribute TimeStamp launchServiceWorkerEnd; + [noscript] attribute TimeStamp dispatchFetchEventStart; + [noscript] attribute TimeStamp dispatchFetchEventEnd; + [noscript] attribute TimeStamp handleFetchEventStart; + [noscript] attribute TimeStamp handleFetchEventEnd; + + // The following are only set when the document is not (only) read from the + // cache + [noscript] readonly attribute TimeStamp domainLookupStart; + [noscript] readonly attribute TimeStamp domainLookupEnd; + [noscript] readonly attribute TimeStamp connectStart; + [noscript] readonly attribute TimeStamp tcpConnectEnd; + [noscript] readonly attribute TimeStamp secureConnectionStart; + [noscript] readonly attribute TimeStamp connectEnd; + [noscript] readonly attribute TimeStamp requestStart; + [noscript] readonly attribute TimeStamp responseStart; + [noscript] readonly attribute TimeStamp responseEnd; + + // The redirect attributes timings must be writeble, se we can transfer + // the data from one channel to the redirected channel. + [noscript] attribute TimeStamp redirectStart; + [noscript] attribute TimeStamp redirectEnd; + + // The initiator type + [noscript] attribute AString initiatorType; + + // This flag should be set to false only if a cross-domain redirect occurred + [noscript] attribute boolean allRedirectsSameOrigin; + // This flag is set to false if the timing allow check fails + [noscript] attribute boolean allRedirectsPassTimingAllowCheck; + // Implements the timing-allow-check to determine if we should report + // timing info for the resourceTiming object. + [noscript] boolean timingAllowCheck(in nsIPrincipal origin); + %{C++ + inline bool TimingAllowCheck(nsIPrincipal* aOrigin) { + bool allowed = false; + return NS_SUCCEEDED(TimingAllowCheck(aOrigin, &allowed)) && allowed; + } + %} + + // The following are only set if the document is (partially) read from the + // cache + [noscript] readonly attribute TimeStamp cacheReadStart; + [noscript] readonly attribute TimeStamp cacheReadEnd; + + // All following are PRTime versions of the above. + readonly attribute PRTime channelCreationTime; + readonly attribute PRTime asyncOpenTime; + readonly attribute PRTime launchServiceWorkerStartTime; + readonly attribute PRTime launchServiceWorkerEndTime; + readonly attribute PRTime dispatchFetchEventStartTime; + readonly attribute PRTime dispatchFetchEventEndTime; + readonly attribute PRTime handleFetchEventStartTime; + readonly attribute PRTime handleFetchEventEndTime; + readonly attribute PRTime domainLookupStartTime; + readonly attribute PRTime domainLookupEndTime; + readonly attribute PRTime connectStartTime; + readonly attribute PRTime tcpConnectEndTime; + readonly attribute PRTime secureConnectionStartTime; + readonly attribute PRTime connectEndTime; + readonly attribute PRTime requestStartTime; + readonly attribute PRTime responseStartTime; + readonly attribute PRTime responseEndTime; + readonly attribute PRTime cacheReadStartTime; + readonly attribute PRTime cacheReadEndTime; + readonly attribute PRTime redirectStartTime; + readonly attribute PRTime redirectEndTime; + + // If this attribute is false, this resource MUST NOT be reported in resource timing. + [noscript] attribute boolean reportResourceTiming; + + readonly attribute nsIArray serverTiming; + nsServerTimingArrayRef getNativeServerTiming(); +}; diff --git a/netwerk/base/nsITraceableChannel.idl b/netwerk/base/nsITraceableChannel.idl new file mode 100644 index 0000000000..4d325d4fcb --- /dev/null +++ b/netwerk/base/nsITraceableChannel.idl @@ -0,0 +1,37 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +interface nsIStreamListener; + +/** + * A channel implementing this interface allows one to intercept its data by + * inserting intermediate stream listeners. + */ +[scriptable, uuid(68167b0b-ef34-4d79-a09a-8045f7c5140e)] +interface nsITraceableChannel : nsISupports +{ + /* + * Replace the channel's listener with a new one, and return the listener + * the channel used to have. The new listener intercepts OnStartRequest, + * OnDataAvailable and OnStopRequest calls and must pass them to + * the original listener after examination. If multiple callers replace + * the channel's listener, a chain of listeners is created. + * The caller of setNewListener has no way to control at which place + * in the chain its listener is placed. + * + * @param aMustApplyContentConversion Pass true if the new listener requires + * content conversion to already be applied by the channel. + * + * Note: The caller of setNewListener must not delay passing + * OnStartRequest to the original listener. + * + * Note2: A channel may restrict when the listener can be replaced. + * It is not recommended to allow listener replacement after OnStartRequest + * has been called. + */ + nsIStreamListener setNewListener(in nsIStreamListener aListener, [optional] in boolean aMustApplyContentConversion); +}; diff --git a/netwerk/base/nsITransport.idl b/netwerk/base/nsITransport.idl new file mode 100644 index 0000000000..c9aaa94083 --- /dev/null +++ b/netwerk/base/nsITransport.idl @@ -0,0 +1,163 @@ +/* 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 "nsISupports.idl" + +interface nsIInputStream; +interface nsIOutputStream; +interface nsITransportEventSink; +interface nsIEventTarget; + +/** + * nsITransport + * + * This interface provides a common way of accessing i/o streams connected + * to some resource. This interface does not in any way specify the resource. + * It provides methods to open blocking or non-blocking, buffered or unbuffered + * streams to the resource. The name "transport" is meant to connote the + * inherent data transfer implied by this interface (i.e., data is being + * transfered in some fashion via the streams exposed by this interface). + * + * A transport can have an event sink associated with it. The event sink + * receives transport-specific events as the transfer is occuring. For a + * socket transport, these events can include status about the connection. + * See nsISocketTransport for more info about socket transport specifics. + */ +[scriptable, uuid(2a8c6334-a5e6-4ec3-9865-1256541446fb)] +interface nsITransport : nsISupports +{ + /** + * Open flags. + */ + const unsigned long OPEN_BLOCKING = 1<<0; + const unsigned long OPEN_UNBUFFERED = 1<<1; + + /** + * Open an input stream on this transport. + * + * Flags have the following meaning: + * + * OPEN_BLOCKING + * If specified, then the resulting stream will have blocking stream + * semantics. This means that if the stream has no data and is not + * closed, then reading from it will block the calling thread until + * at least one byte is available or until the stream is closed. + * If this flag is NOT specified, then the stream has non-blocking + * stream semantics. This means that if the stream has no data and is + * not closed, then reading from it returns NS_BASE_STREAM_WOULD_BLOCK. + * In addition, in non-blocking mode, the stream is guaranteed to + * support nsIAsyncInputStream. This interface allows the consumer of + * the stream to be notified when the stream can again be read. + * + * OPEN_UNBUFFERED + * If specified, the resulting stream may not support ReadSegments. + * ReadSegments is only gauranteed to be implemented when this flag is + * NOT specified. + * + * @param aFlags + * optional transport specific flags. + * @param aSegmentSize + * if OPEN_UNBUFFERED is not set, then this parameter specifies the + * size of each buffer segment (pass 0 to use default value). + * @param aSegmentCount + * if OPEN_UNBUFFERED is not set, then this parameter specifies the + * maximum number of buffer segments (pass 0 to use default value). + */ + nsIInputStream openInputStream(in unsigned long aFlags, + in unsigned long aSegmentSize, + in unsigned long aSegmentCount); + + /** + * Open an output stream on this transport. + * + * Flags have the following meaning: + * + * OPEN_BLOCKING + * If specified, then the resulting stream will have blocking stream + * semantics. This means that if the stream is full and is not closed, + * then writing to it will block the calling thread until ALL of the + * data can be written or until the stream is closed. If this flag is + * NOT specified, then the stream has non-blocking stream semantics. + * This means that if the stream is full and is not closed, then writing + * to it returns NS_BASE_STREAM_WOULD_BLOCK. In addition, in non- + * blocking mode, the stream is guaranteed to support + * nsIAsyncOutputStream. This interface allows the consumer of the + * stream to be notified when the stream can again accept more data. + * + * OPEN_UNBUFFERED + * If specified, the resulting stream may not support WriteSegments and + * WriteFrom. WriteSegments and WriteFrom are only guaranteed to be + * implemented when this flag is NOT specified. + * + * @param aFlags + * optional transport specific flags. + * @param aSegmentSize + * if OPEN_UNBUFFERED is not set, then this parameter specifies the + * size of each buffer segment (pass 0 to use default value). + * @param aSegmentCount + * if OPEN_UNBUFFERED is not set, then this parameter specifies the + * maximum number of buffer segments (pass 0 to use default value). + */ + nsIOutputStream openOutputStream(in unsigned long aFlags, + in unsigned long aSegmentSize, + in unsigned long aSegmentCount); + + /** + * Close the transport and any open streams. + * + * @param aReason + * the reason for closing the stream. + */ + void close(in nsresult aReason); + + /** + * Set the transport event sink. + * + * @param aSink + * receives transport layer notifications + * @param aEventTarget + * indicates the event target to which the notifications should + * be delivered. if NULL, then the notifications may occur on + * any thread. + */ + void setEventSink(in nsITransportEventSink aSink, + in nsIEventTarget aEventTarget); + + /** + * Generic nsITransportEventSink status codes. nsITransport + * implementations may override these status codes with their own more + * specific status codes (e.g., see nsISocketTransport). + * + * In C++, these constants have a type of uint32_t, so C++ callers must use + * the NS_NET_STATUS_* constants defined below, which have a type of + * nsresult. + */ + const unsigned long STATUS_READING = 0x804b0008; + const unsigned long STATUS_WRITING = 0x804b0009; +}; + +[scriptable, uuid(EDA4F520-67F7-484b-A691-8C3226A5B0A6)] +interface nsITransportEventSink : nsISupports +{ + /** + * Transport status notification. + * + * @param aTransport + * the transport sending this status notification. + * @param aStatus + * the transport status (resolvable to a string using + * nsIErrorService). See nsISocketTransport for socket specific + * status codes and more comments. + * @param aProgress + * the amount of data either read or written depending on the value + * of the status code. this value is relative to aProgressMax. + * @param aProgressMax + * the maximum amount of data that will be read or written. if + * unknown, -1 will be passed. + */ + void onTransportStatus(in nsITransport aTransport, + in nsresult aStatus, + in long long aProgress, + in long long aProgressMax); +}; diff --git a/netwerk/base/nsIUDPSocket.idl b/netwerk/base/nsIUDPSocket.idl new file mode 100644 index 0000000000..c8217dc5d3 --- /dev/null +++ b/netwerk/base/nsIUDPSocket.idl @@ -0,0 +1,347 @@ +/* vim:set ts=4 sw=4 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 "nsISupports.idl" + +interface nsINetAddr; +interface nsIUDPSocketListener; +interface nsIUDPMessage; +interface nsISocketTransport; +interface nsIOutputStream; +interface nsIInputStream; +interface nsIPrincipal; + +%{ C++ +#include "nsTArrayForwardDeclare.h" +namespace mozilla { +namespace net { +union NetAddr; +} +} +%} +native NetAddr(mozilla::net::NetAddr); +[ptr] native NetAddrPtr(mozilla::net::NetAddr); +[ref] native Uint8TArrayRef(FallibleTArray<uint8_t>); + +/** + * nsIUDPSocket + * + * An interface to a UDP socket that can accept incoming connections. + */ +[scriptable, uuid(d423bf4e-4499-40cf-bc03-153e2bf206d1)] +interface nsIUDPSocket : nsISupports +{ + /** + * init + * + * This method initializes a UDP socket. + * + * @param aPort + * The port of the UDP socket. Pass -1 to indicate no preference, + * and a port will be selected automatically. + * @param aLoopbackOnly + * If true, the UDP socket will only respond to connections on the + * local loopback interface. Otherwise, it will accept connections + * from any interface. To specify a particular network interface, + * use initWithAddress. + * @param aPrincipal + * The principal connected to this socket. + * @param aAddressReuse + * If true, the socket is allowed to be bound to an address that is + * already in use. Default is true. + */ + [optional_argc] void init(in long aPort, + in boolean aLoopbackOnly, + in nsIPrincipal aPrincipal, + [optional] in boolean aAddressReuse); + + [optional_argc] void init2(in AUTF8String aAddr, + in long aPort, + in nsIPrincipal aPrincipal, + [optional] in boolean aAddressReuse); + + /** + * initWithAddress + * + * This method initializes a UDP socket, and binds it to a particular + * local address (and hence a particular local network interface). + * + * @param aAddr + * The address to which this UDP socket should be bound. + * @param aPrincipal + * The principal connected to this socket. + * @param aAddressReuse + * If true, the socket is allowed to be bound to an address that is + * already in use. Default is true. + */ + [noscript, optional_argc] void initWithAddress([const] in NetAddrPtr aAddr, + in nsIPrincipal aPrincipal, + [optional] in boolean aAddressReuse); + + /** + * close + * + * This method closes a UDP socket. This does not affect already + * connected client sockets (i.e., the nsISocketTransport instances + * created from this UDP socket). This will cause the onStopListening + * event to asynchronously fire with a status of NS_BINDING_ABORTED. + */ + void close(); + + /** + * asyncListen + * + * This method puts the UDP socket in the listening state. It will + * asynchronously listen for and accept client connections. The listener + * will be notified once for each client connection that is accepted. The + * listener's onSocketAccepted method will be called on the same thread + * that called asyncListen (the calling thread must have a nsIEventTarget). + * + * The listener will be passed a reference to an already connected socket + * transport (nsISocketTransport). See below for more details. + * + * @param aListener + * The listener to be notified when client connections are accepted. + */ + void asyncListen(in nsIUDPSocketListener aListener); + + /** + * connect + * + * This method connects the UDP socket to a remote UDP address. + * + * @param aRemoteAddr + * The remote address to connect to + */ + void connect([const] in NetAddrPtr aAddr); + + /** + * Returns the local address of this UDP socket + */ + readonly attribute nsINetAddr localAddr; + + /** + * Returns the port of this UDP socket. + */ + readonly attribute long port; + + /** + * Returns the address to which this UDP socket is bound. Since a + * UDP socket may be bound to multiple network devices, this address + * may not necessarily be specific to a single network device. In the + * case of an IP socket, the IP address field would be zerod out to + * indicate a UDP socket bound to all network devices. Therefore, + * this method cannot be used to determine the IP address of the local + * system. See nsIDNSService::myHostName if this is what you need. + */ + [noscript] NetAddr getAddress(); + + /** + * send + * + * Send out the datagram to specified remote host and port. + * DNS lookup will be triggered. + * + * @param host The remote host name. + * @param port The remote port. + * @param data The buffer containing the data to be written. + * @return number of bytes written. (0 or length of data) + */ + unsigned long send(in AUTF8String host, in unsigned short port, + in Array<uint8_t> data); + + /** + * sendWithAddr + * + * Send out the datagram to specified remote host and port. + * + * @param addr The remote host address. + * @param data The buffer containing the data to be written. + * @return number of bytes written. (0 or length of data) + */ + unsigned long sendWithAddr(in nsINetAddr addr, + in Array<uint8_t> data); + + /** + * sendWithAddress + * + * Send out the datagram to specified remote address and port. + * + * @param addr The remote host address. + * @param data The buffer containing the data to be written. + * @return number of bytes written. (0 or length of data) + */ + [noscript] unsigned long sendWithAddress([const] in NetAddrPtr addr, + in Array<uint8_t> data); + + /** + * sendBinaryStream + * + * Send out the datagram to specified remote address and port. + * + * @param host The remote host name. + * @param port The remote port. + * @param stream The input stream to be sent. This must be a buffered stream implementation. + */ + void sendBinaryStream(in AUTF8String host, in unsigned short port, + in nsIInputStream stream); + + /** + * sendBinaryStreamWithAddress + * + * Send out the datagram to specified remote address and port. + * + * @param addr The remote host address. + * @param stream The input stream to be sent. This must be a buffered stream implementation. + */ + void sendBinaryStreamWithAddress([const] in NetAddrPtr addr, + in nsIInputStream stream); + + /** + * joinMulticast + * + * Join the multicast group specified by |addr|. You are then able to + * receive future datagrams addressed to the group. + * + * @param addr + * The multicast group address. + * @param iface + * The local address of the interface on which to join the group. If + * this is not specified, the OS may join the group on all interfaces + * or only the primary interface. + */ + void joinMulticast(in AUTF8String addr, [optional] in AUTF8String iface); + [noscript] void joinMulticastAddr([const] in NetAddr addr, + [const, optional] in NetAddrPtr iface); + + /** + * leaveMulticast + * + * Leave the multicast group specified by |addr|. You will no longer + * receive future datagrams addressed to the group. + * + * @param addr + * The multicast group address. + * @param iface + * The local address of the interface on which to leave the group. + * If this is not specified, the OS may leave the group on all + * interfaces or only the primary interface. + */ + void leaveMulticast(in AUTF8String addr, [optional] in AUTF8String iface); + [noscript] void leaveMulticastAddr([const] in NetAddr addr, + [const, optional] in NetAddrPtr iface); + + /** + * multicastLoopback + * + * Whether multicast datagrams sent via this socket should be looped back to + * this host (assuming this host has joined the relevant group). Defaults + * to true. + * Note: This is currently write-only. + */ + attribute boolean multicastLoopback; + + /** + * multicastInterface + * + * The interface that should be used for sending future multicast datagrams. + * Note: This is currently write-only. + */ + attribute AUTF8String multicastInterface; + + /** + * multicastInterfaceAddr + * + * The interface that should be used for sending future multicast datagrams. + * Note: This is currently write-only. + */ + [noscript] attribute NetAddr multicastInterfaceAddr; + + /** + * recvBufferSize + * + * The size of the receive buffer. Default depends on the OS. + */ + [noscript] attribute long recvBufferSize; + + /** + * sendBufferSize + * + * The size of the send buffer. Default depends on the OS. + */ + [noscript] attribute long sendBufferSize; +}; + +/** + * nsIUDPSocketListener + * + * This interface is notified whenever a UDP socket accepts a new connection. + * The transport is in the connected state, and read/write streams can be opened + * using the normal nsITransport API. The address of the client can be found by + * calling the nsISocketTransport::GetAddress method or by inspecting + * nsISocketTransport::GetHost, which returns a string representation of the + * client's IP address (NOTE: this may be an IPv4 or IPv6 string literal). + */ +[scriptable, uuid(2E4B5DD3-7358-4281-B81F-10C62EF39CB5)] +interface nsIUDPSocketListener : nsISupports +{ + /** + * onPacketReceived + * + * This method is called when a client sends an UDP packet. + * + * @param aSocket + * The UDP socket. + * @param aMessage + * The message. + */ + void onPacketReceived(in nsIUDPSocket aSocket, + in nsIUDPMessage aMessage); + + /** + * onStopListening + * + * This method is called when the listening socket stops for some reason. + * The UDP socket is effectively dead after this notification. + * + * @param aSocket + * The UDP socket. + * @param aStatus + * The reason why the UDP socket stopped listening. If the + * UDP socket was manually closed, then this value will be + * NS_BINDING_ABORTED. + */ + void onStopListening(in nsIUDPSocket aSocket, in nsresult aStatus); +}; + +/** + * nsIUDPMessage + * + * This interface is used to encapsulate an incomming UDP message + */ +[scriptable, builtinclass, uuid(afdc743f-9cc0-40d8-b442-695dc54bbb74)] +interface nsIUDPMessage : nsISupports +{ + /** + * Address of the source of the message + */ + readonly attribute nsINetAddr fromAddr; + + /** + * Data of the message + */ + readonly attribute ACString data; + + /** + * Stream to send a response + */ + readonly attribute nsIOutputStream outputStream; + + /** + * Raw Data of the message + */ + [implicit_jscontext] readonly attribute jsval rawData; + [noscript, notxpcom, nostdcall] Uint8TArrayRef getDataAsTArray(); +}; diff --git a/netwerk/base/nsIURI.idl b/netwerk/base/nsIURI.idl new file mode 100644 index 0000000000..df1a98e873 --- /dev/null +++ b/netwerk/base/nsIURI.idl @@ -0,0 +1,322 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +/** + * URIs are essentially structured names for things -- anything. This interface + * provides accessors to get the most basic components of an URI. + * If you need to change some parts of the URI use nsIURIMutator. + * Subclasses, including nsIURL, impose greater structure on the URI. + * + * This interface follows Tim Berners-Lee's URI spec (RFC3986) [1], where the + * basic URI components are defined as such: + * <pre> + * ftp://username:password@hostname:portnumber/pathname?query#ref + * \ / \ / \ / \ /\ / \ / \ / + * - --------------- ------ -------- ------- --- - + * | | | | | | | + * | | | | FilePath Query Ref + * | | | Port \ / + * | | Host / ------------ + * | UserPass / | + * Scheme / Path + * \ / + * -------------------------------- + * | + * PrePath + * </pre> + * The definition of the URI components has been extended to allow for + * internationalized domain names [2] and the more generic IRI structure [3]. + * + * [1] https://tools.ietf.org/html/rfc3986 + * [2] https://tools.ietf.org/html/rfc5890 + * [3] https://tools.ietf.org/html/rfc3987 + */ + +%{C++ +#include "nsString.h" + +#undef GetPort // XXX Windows! +#undef SetPort // XXX Windows! + +namespace mozilla { +class Encoding; +namespace ipc { +class URIParams; +} // namespace ipc +} // namespace mozilla +%} + +[ptr] native Encoding(const mozilla::Encoding); +[ref] native URIParams(mozilla::ipc::URIParams); +interface nsIURIMutator; + +/** + * nsIURI - interface for an uniform resource identifier w/ i18n support. + * + * AUTF8String attributes may contain unescaped UTF-8 characters. + * Consumers should be careful to escape the UTF-8 strings as necessary, but + * should always try to "display" the UTF-8 version as provided by this + * interface. + * + * AUTF8String attributes may also contain escaped characters. + * + * Unescaping URI segments is unadvised unless there is intimate + * knowledge of the underlying charset or there is no plan to display (or + * otherwise enforce a charset on) the resulting URI substring. + * + * The correct way to create an nsIURI from a string is via + * nsIIOService.newURI. + * + * NOTE: nsBinaryInputStream::ReadObject contains a hackaround to intercept the + * old (pre-gecko6) nsIURI IID and swap in the current IID instead, in order + * for sessionstore to work after an upgrade. If this IID is revved further, + * we will need to add additional checks there for all intermediate IIDs, until + * ContentPrincipal is fixed to serialize its URIs as nsISupports (bug 662693). + */ +[scriptable, builtinclass, uuid(92073a54-6d78-4f30-913a-b871813208c6)] +interface nsIURI : nsISupports +{ + /************************************************************************ + * The URI is broken down into the following principal components: + */ + + /** + * Returns a string representation of the URI. + * + * Some characters may be escaped. + */ + readonly attribute AUTF8String spec; + +%{ C++ + // An infallible wrapper for GetSpec() that returns a failure indication + // string if GetSpec() fails. It is most useful for creating + // logging/warning/error messages produced for human consumption, and when + // matching a URI spec against a fixed spec such as about:blank. + nsCString GetSpecOrDefault() + { + nsCString spec; + nsresult rv = GetSpec(spec); + if (NS_FAILED(rv)) { + spec.AssignLiteral("[nsIURI::GetSpec failed]"); + } + return spec; + } +%} + + /** + * The prePath (eg. scheme://user:password@host:port) returns the string + * before the path. This is useful for authentication or managing sessions. + * + * Some characters may be escaped. + */ + readonly attribute AUTF8String prePath; + + /** + * The Scheme is the protocol to which this URI refers. The scheme is + * restricted to the US-ASCII charset per RFC3986. + */ + readonly attribute ACString scheme; + + /** + * The username:password (or username only if value doesn't contain a ':') + * + * Some characters may be escaped. + */ + readonly attribute AUTF8String userPass; + + /** + * The optional username and password, assuming the preHost consists of + * username:password. + * + * Some characters may be escaped. + */ + readonly attribute AUTF8String username; + readonly attribute AUTF8String password; + + /** + * The host:port (or simply the host, if port == -1). + */ + readonly attribute AUTF8String hostPort; + + /** + * The host is the internet domain name to which this URI refers. It could + * be an IPv4 (or IPv6) address literal. Otherwise it is an ASCII or punycode + * encoded string. + */ + readonly attribute AUTF8String host; + + /** + * A port value of -1 corresponds to the protocol's default port (eg. -1 + * implies port 80 for http URIs). + */ + readonly attribute long port; + + /** + * The path, typically including at least a leading '/' (but may also be + * empty, depending on the protocol). + * + * Some characters may be escaped. + * + * This attribute contains query and ref parts for historical reasons. + * Use the 'filePath' attribute if you do not want those parts included. + */ + readonly attribute AUTF8String pathQueryRef; + + + /************************************************************************ + * An URI supports the following methods: + */ + + /** + * URI equivalence test (not a strict string comparison). + * + * eg. http://foo.com:80/ == http://foo.com/ + */ + boolean equals(in nsIURI other); + + /** + * An optimization to do scheme checks without requiring the users of nsIURI + * to GetScheme, thereby saving extra allocating and freeing. Returns true if + * the schemes match (case ignored). + */ + [infallible] boolean schemeIs(in string scheme); + + /** + * This method resolves a relative string into an absolute URI string, + * using this URI as the base. + * + * NOTE: some implementations may have no concept of a relative URI. + */ + AUTF8String resolve(in AUTF8String relativePath); + + + /************************************************************************ + * Additional attributes: + */ + + /** + * The URI spec with an ASCII compatible encoding. Host portion follows + * the IDNA draft spec. Other parts are URL-escaped per the rules of + * RFC2396. The result is strictly ASCII. + */ + readonly attribute ACString asciiSpec; + + /** + * The host:port (or simply the host, if port == -1), with an ASCII compatible + * encoding. Host portion follows the IDNA draft spec. The result is strictly + * ASCII. + */ + readonly attribute ACString asciiHostPort; + + /** + * The URI host with an ASCII compatible encoding. Follows the IDNA + * draft spec for converting internationalized domain names (UTF-8) to + * ASCII for compatibility with existing internet infrasture. + */ + readonly attribute ACString asciiHost; + + /************************************************************************ + * Additional attribute & methods added for .ref support: + */ + + /** + * Returns the reference portion (the part after the "#") of the URI. + * If there isn't one, an empty string is returned. + * + * Some characters may be escaped. + */ + readonly attribute AUTF8String ref; + + /** + * URI equivalence test (not a strict string comparison), ignoring + * the value of the .ref member. + * + * eg. http://foo.com/# == http://foo.com/ + * http://foo.com/#aaa == http://foo.com/#bbb + */ + boolean equalsExceptRef(in nsIURI other); + + /** + * returns a string for the current URI with the ref element cleared. + */ + readonly attribute AUTF8String specIgnoringRef; + + /** + * Returns if there is a reference portion (the part after the "#") of the URI. + */ + readonly attribute boolean hasRef; + + /************************************************************************ + * Additional attributes added for .query support: + */ + + /** + * Returns a path including the directory and file portions of a + * URL. For example, the filePath of "http://host/foo/bar.html#baz" + * is "/foo/bar.html". + * + * Some characters may be escaped. + */ + readonly attribute AUTF8String filePath; + + /** + * Returns the query portion (the part after the "?") of the URL. + * If there isn't one, an empty string is returned. + * + * Some characters may be escaped. + */ + readonly attribute AUTF8String query; + + /** + * If the URI has a punycode encoded hostname, this will hold the UTF8 + * representation of that hostname (if that representation doesn't contain + * blacklisted characters, and the network.IDN_show_punycode pref is false) + * Otherwise, if the hostname is ASCII, it will return the same as .asciiHost + */ + readonly attribute AUTF8String displayHost; + + /** + * The displayHost:port (or simply the displayHost, if port == -1). + */ + readonly attribute AUTF8String displayHostPort; + + /** + * Returns the same as calling .spec, only with a UTF8 encoded hostname + * (if that hostname doesn't contain blacklisted characters, and + * the network.IDN_show_punycode pref is false) + */ + readonly attribute AUTF8String displaySpec; + + /** + * Returns the same as calling .prePath, only with a UTF8 encoded hostname + * (if that hostname doesn't contain blacklisted characters, and + * the network.IDN_show_punycode pref is false) + */ + readonly attribute AUTF8String displayPrePath; + + /** + * Returns an nsIURIMutator that can be used to make changes to the URI. + * After performing the setter operations on the mutator, one may call + * mutator.finalize() to get a new immutable URI with the desired + * properties. + */ + nsIURIMutator mutate(); + + /** + * Serializes a URI object to a URIParams data structure in order for being + * passed over IPC. For deserialization, see nsIURIMutator. + */ + [noscript, notxpcom] void serialize(in URIParams aParams); + + %{C++ + // MOZ_DBG support + friend std::ostream& operator<<(std::ostream& aOut, const nsIURI& aURI) { + nsIURI* uri = const_cast<nsIURI*>(&aURI); + return aOut << "nsIURI { " << uri->GetSpecOrDefault() << " }"; + } + %} +}; diff --git a/netwerk/base/nsIURIMutator.idl b/netwerk/base/nsIURIMutator.idl new file mode 100644 index 0000000000..c3afa21075 --- /dev/null +++ b/netwerk/base/nsIURIMutator.idl @@ -0,0 +1,557 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "nsISupports.idl" +interface nsIURI; +interface nsIObjectInputStream; +interface nsIURIMutator; + +%{C++ +#include "nsString.h" +#include "nsCOMPtr.h" +#include <functional> + +#undef SetPort // XXX Windows! + +namespace mozilla { +class Encoding; +} + +namespace mozilla { +namespace ipc { +class URIParams; +} // namespace ipc +} // namespace mozilla + +template <class T> +class BaseURIMutator +{ +// This is the base class that can be extended by implementors of nsIURIMutator +// in order to avoid code duplication +// Class type T should be the type of the class that implements nsIURI +protected: + virtual T* Create() + { + return new T(); + } + + [[nodiscard]] nsresult InitFromURI(T* aURI) + { + nsCOMPtr<nsIURI> clone; + nsresult rv = aURI->Clone(getter_AddRefs(clone)); + if (NS_FAILED(rv)) { + return rv; + } + mURI = static_cast<T*>(clone.get()); + return NS_OK; + } + + [[nodiscard]] nsresult InitFromInputStream(nsIObjectInputStream* aStream) + { + RefPtr<T> uri = Create(); + nsresult rv = uri->ReadPrivate(aStream); + if (NS_FAILED(rv)) { + return rv; + } + mURI = std::move(uri); + return NS_OK; + } + + [[nodiscard]] nsresult InitFromIPCParams(const mozilla::ipc::URIParams& aParams) + { + RefPtr<T> uri = Create(); + bool ret = uri->Deserialize(aParams); + if (!ret) { + return NS_ERROR_FAILURE; + } + mURI = std::move(uri); + return NS_OK; + } + + [[nodiscard]] nsresult InitFromSpec(const nsACString& aSpec) + { + nsresult rv = NS_OK; + RefPtr<T> uri; + if (mURI) { + // This only works because all other Init methods create a new object + mURI.swap(uri); + } else { + uri = Create(); + } + + rv = uri->SetSpecInternal(aSpec); + if (NS_FAILED(rv)) { + return rv; + } + mURI = std::move(uri); + return NS_OK; + } + + RefPtr<T> mURI; +}; + +// Since most implementations of nsIURIMutator would extend BaseURIMutator, +// some methods would have the same implementation. We provide a useful macro +// to avoid code duplication. +#define NS_DEFINE_NSIMUTATOR_COMMON \ + [[nodiscard]] NS_IMETHOD \ + Deserialize(const mozilla::ipc::URIParams& aParams) override \ + { \ + return InitFromIPCParams(aParams); \ + } \ + \ + [[nodiscard]] NS_IMETHOD \ + Finalize(nsIURI** aURI) override \ + { \ + mURI.forget(aURI); return NS_OK; \ + } \ + \ + [[nodiscard]] NS_IMETHOD \ + SetSpec(const nsACString& aSpec, nsIURIMutator** aMutator) override \ + { \ + if (aMutator) NS_ADDREF(*aMutator = this); \ + return InitFromSpec(aSpec); \ + } \ + +// Implements AddRef, Release and QueryInterface for the mutator +#define NS_IMPL_NSIURIMUTATOR_ISUPPORTS(aClass, ...) \ + NS_IMPL_ADDREF(aClass) \ + NS_IMPL_RELEASE(aClass) \ + NS_IMPL_NSIURIMUTATOR_QUERY_INTERFACE(aClass, __VA_ARGS__) \ + +// The list of interfaces is queried and an AddRef-ed pointer is returned if +// there is a match. Otherwise, we call QueryInterface on mURI and return. +// The reason for this specialized QueryInterface implementation is that we +// we want to be able to instantiate the mutator for a given CID of a +// nsIURI implementation, call nsISerializable.Read() on the mutator to +// deserialize the URI then QueryInterface the mutator to an nsIURI interface. +// See bug 1442239. +// If you QueryInterface a mutator to an interface of the URI +// implementation this is similar to calling Finalize. +#define NS_IMPL_NSIURIMUTATOR_QUERY_INTERFACE(aClass, ...) \ + static_assert(MOZ_ARG_COUNT(__VA_ARGS__) > 0, \ + "Need more arguments"); \ + NS_INTERFACE_MAP_BEGIN(aClass) \ + nsCOMPtr<nsIURI> uri; \ + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIURIMutator) \ + MOZ_FOR_EACH(NS_INTERFACE_MAP_ENTRY, (), (__VA_ARGS__)) \ + if (aIID.Equals(NS_GET_IID(nsIClassInfo))) { \ + foundInterface = nullptr; \ + } else \ + if (mURI && \ + NS_SUCCEEDED(mURI->QueryInterface(aIID, getter_AddRefs(uri)))) { \ + mURI = nullptr; \ + foundInterface = uri.get(); \ + } else \ + NS_INTERFACE_MAP_END \ + +%} + +[ptr] native Encoding(const mozilla::Encoding); +[ref] native const_URIParams_ref(const mozilla::ipc::URIParams); + +[scriptable, builtinclass, uuid(1fc53257-898b-4c5e-b69c-05bc84b4cd8f)] +interface nsIURISetSpec : nsISupports +{ + /** + * This setter is different from all other setters because it may be used to + * initialize the object. We define it separately allowing mutator implementors + * to define it separately, while the rest of the setters may be simply + * forwarded to the mutable URI. + */ + [must_use] nsIURIMutator setSpec(in AUTF8String aSpec); +}; + +/** + * These methods allow the mutator to change various parts of the URI. + * They return the same nsIURIMutator so that we may chain setter operations: + * Example: + * let newURI = uri.mutate() + * .setSpec("http://example.com") + * .setQuery("hello") + * .finalize(); + */ +[scriptable, builtinclass, uuid(5403a6ec-99d7-405e-8b45-9f805bbdfcef)] +interface nsIURISetters : nsIURISetSpec +{ + /** + * Setting the scheme outside of a protocol handler implementation is highly + * discouraged since that will generally lead to incorrect results. + */ + [must_use] nsIURIMutator setScheme(in AUTF8String aScheme); + [must_use] nsIURIMutator setUserPass(in AUTF8String aUserPass); + [must_use] nsIURIMutator setUsername(in AUTF8String aUsername); + [must_use] nsIURIMutator setPassword(in AUTF8String aPassword); + + /** + * If you setHostPort to a value that only has a host part, the port + * will not be reset. To reset the port set it to -1 beforehand. + * If setting the host succeeds, this method will return NS_OK, even if + * setting the port fails (error in parsing the port, or value out of range) + */ + [must_use] nsIURIMutator setHostPort(in AUTF8String aHostPort); + [must_use] nsIURIMutator setHost(in AUTF8String aHost); + [must_use] nsIURIMutator setPort(in long aPort); + [must_use] nsIURIMutator setPathQueryRef(in AUTF8String aPathQueryRef); + [must_use] nsIURIMutator setRef(in AUTF8String aRef); + [must_use] nsIURIMutator setFilePath(in AUTF8String aFilePath); + [must_use] nsIURIMutator setQuery(in AUTF8String aQuery); + [must_use, noscript] nsIURIMutator setQueryWithEncoding(in AUTF8String query, in Encoding encoding); +}; + +%{C++ + +// Using this macro instead of NS_FORWARD_SAFE_NSIURISETTERS makes chaining +// setter operations possible. +#define NS_FORWARD_SAFE_NSIURISETTERS_RET(_to) \ + [[nodiscard]] NS_IMETHOD \ + SetScheme(const nsACString& aScheme, nsIURIMutator** aMutator) override \ + { \ + if (aMutator) NS_ADDREF(*aMutator = this); \ + return !_to ? NS_ERROR_NULL_POINTER : _to->SetScheme(aScheme); \ + } \ + [[nodiscard]] NS_IMETHOD \ + SetUserPass(const nsACString& aUserPass, nsIURIMutator** aMutator) override \ + { \ + if (aMutator) NS_ADDREF(*aMutator = this); \ + return !_to ? NS_ERROR_NULL_POINTER : _to->SetUserPass(aUserPass); \ + } \ + [[nodiscard]] NS_IMETHOD \ + SetUsername(const nsACString& aUsername, nsIURIMutator** aMutator) override \ + { \ + if (aMutator) NS_ADDREF(*aMutator = this); \ + return !_to ? NS_ERROR_NULL_POINTER : _to->SetUsername(aUsername); \ + } \ + [[nodiscard]] NS_IMETHOD \ + SetPassword(const nsACString& aPassword, nsIURIMutator** aMutator) override \ + { \ + if (aMutator) NS_ADDREF(*aMutator = this); \ + return !_to ? NS_ERROR_NULL_POINTER : _to->SetPassword(aPassword); \ + } \ + [[nodiscard]] NS_IMETHOD \ + SetHostPort(const nsACString& aHostPort, nsIURIMutator** aMutator) override \ + { \ + if (aMutator) NS_ADDREF(*aMutator = this); \ + return !_to ? NS_ERROR_NULL_POINTER : _to->SetHostPort(aHostPort); \ + } \ + [[nodiscard]] NS_IMETHOD \ + SetHost(const nsACString& aHost, nsIURIMutator** aMutator) override \ + { \ + if (aMutator) NS_ADDREF(*aMutator = this); \ + return !_to ? NS_ERROR_NULL_POINTER : _to->SetHost(aHost); \ + } \ + [[nodiscard]] NS_IMETHOD \ + SetPort(int32_t aPort, nsIURIMutator** aMutator) override \ + { \ + if (aMutator) NS_ADDREF(*aMutator = this); \ + return !_to ? NS_ERROR_NULL_POINTER : _to->SetPort(aPort); \ + } \ + [[nodiscard]] NS_IMETHOD \ + SetPathQueryRef(const nsACString& aPathQueryRef, nsIURIMutator** aMutator) override \ + { \ + if (aMutator) NS_ADDREF(*aMutator = this); \ + return !_to ? NS_ERROR_NULL_POINTER : _to->SetPathQueryRef(aPathQueryRef); \ + } \ + [[nodiscard]] NS_IMETHOD \ + SetRef(const nsACString& aRef, nsIURIMutator** aMutator) override \ + { \ + if (aMutator) NS_ADDREF(*aMutator = this); \ + return !_to ? NS_ERROR_NULL_POINTER : _to->SetRef(aRef); \ + } \ + [[nodiscard]] NS_IMETHOD \ + SetFilePath(const nsACString& aFilePath, nsIURIMutator** aMutator) override \ + { \ + if (aMutator) NS_ADDREF(*aMutator = this); \ + return !_to ? NS_ERROR_NULL_POINTER : _to->SetFilePath(aFilePath); \ + } \ + [[nodiscard]] NS_IMETHOD \ + SetQuery(const nsACString& aQuery, nsIURIMutator** aMutator) override \ + { \ + if (aMutator) NS_ADDREF(*aMutator = this); \ + return !_to ? NS_ERROR_NULL_POINTER : _to->SetQuery(aQuery); \ + } \ + [[nodiscard]] NS_IMETHOD \ + SetQueryWithEncoding(const nsACString& query, const mozilla::Encoding *encoding, nsIURIMutator** aMutator) override \ + { \ + if (aMutator) NS_ADDREF(*aMutator = this); \ + return !_to ? NS_ERROR_NULL_POINTER : _to->SetQueryWithEncoding(query, encoding); \ + } \ + +%} + +[scriptable, builtinclass, uuid(4d1f3103-1c44-4dcd-b717-5d22a697a7d9)] +interface nsIURIMutator : nsIURISetters +{ + /** + * Initalizes the URI by reading IPC URIParams. + * See nsIURI. + */ + [noscript, notxpcom, must_use] + nsresult deserialize(in const_URIParams_ref aParams); + + /** + * Finishes changing or constructing the URI and returns an immutable URI. + */ + [must_use] + nsIURI finalize(); +}; + +%{C++ + +// This templated struct is used to extract the class type of the method +// passed to NS_MutatorMethod. +template <typename Method> +struct nsMethodTypeTraits; + +template <class C, typename R, typename... As> +struct nsMethodTypeTraits<R(C::*)(As...)> +{ + typedef C class_type; +}; + +#ifdef NS_HAVE_STDCALL +template <class C, typename R, typename... As> +struct nsMethodTypeTraits<R(__stdcall C::*)(As...)> +{ + typedef C class_type; +}; +#endif + +// This helper returns a std::function that will be applied on the +// nsIURIMutator. The type of `Interface` will be deduced from the method type. +// aMethod will be called on the target object if it successfully QIs to +// `Interface`, and the arguments will be passed to the call. +template <typename Method, typename... Args> +const std::function<nsresult(nsIURIMutator*)> +NS_MutatorMethod(Method aMethod, Args ...aArgs) +{ + // Capture arguments by value, otherwise we crash. + return [=](nsIURIMutator* aMutator) { + typedef typename nsMethodTypeTraits<Method>::class_type Interface; + nsresult rv; + nsCOMPtr<Interface> target = do_QueryInterface(aMutator, &rv); + NS_ENSURE_SUCCESS(rv, rv); + rv = (target->*aMethod)(aArgs...); + if (NS_FAILED(rv)) return rv; + return NS_OK; + }; +} + +// This class provides a useful helper that allows chaining of setter operations +class MOZ_STACK_CLASS NS_MutateURI +{ +public: + explicit NS_MutateURI(nsIURI* aURI); + explicit NS_MutateURI(const char * aContractID); + + explicit NS_MutateURI(nsIURIMutator* m) + { + mStatus = m ? NS_OK : NS_ERROR_NULL_POINTER; + mMutator = m; + NS_ENSURE_SUCCESS_VOID(mStatus); + } + + NS_MutateURI& SetSpec(const nsACString& aSpec) + { + if (NS_FAILED(mStatus)) { + return *this; + } + mStatus = mMutator->SetSpec(aSpec, nullptr); + return *this; + } + NS_MutateURI& SetScheme(const nsACString& aScheme) + { + if (NS_FAILED(mStatus)) { + return *this; + } + mStatus = mMutator->SetScheme(aScheme, nullptr); + NS_ENSURE_SUCCESS(mStatus, *this); + return *this; + } + NS_MutateURI& SetUserPass(const nsACString& aUserPass) + { + if (NS_FAILED(mStatus)) { + return *this; + } + mStatus = mMutator->SetUserPass(aUserPass, nullptr); + return *this; + } + NS_MutateURI& SetUsername(const nsACString& aUsername) + { + if (NS_FAILED(mStatus)) { + return *this; + } + mStatus = mMutator->SetUsername(aUsername, nullptr); + NS_ENSURE_SUCCESS(mStatus, *this); + return *this; + } + NS_MutateURI& SetPassword(const nsACString& aPassword) + { + if (NS_FAILED(mStatus)) { + return *this; + } + mStatus = mMutator->SetPassword(aPassword, nullptr); + NS_ENSURE_SUCCESS(mStatus, *this); + return *this; + } + NS_MutateURI& SetHostPort(const nsACString& aHostPort) + { + if (NS_FAILED(mStatus)) { + return *this; + } + mStatus = mMutator->SetHostPort(aHostPort, nullptr); + NS_ENSURE_SUCCESS(mStatus, *this); + return *this; + } + NS_MutateURI& SetHost(const nsACString& aHost) + { + if (NS_FAILED(mStatus)) { + return *this; + } + mStatus = mMutator->SetHost(aHost, nullptr); + NS_ENSURE_SUCCESS(mStatus, *this); + return *this; + } + NS_MutateURI& SetPort(int32_t aPort) + { + if (NS_FAILED(mStatus)) { + return *this; + } + mStatus = mMutator->SetPort(aPort, nullptr); + NS_ENSURE_SUCCESS(mStatus, *this); + return *this; + } + NS_MutateURI& SetPathQueryRef(const nsACString& aPathQueryRef) + { + if (NS_FAILED(mStatus)) { + return *this; + } + mStatus = mMutator->SetPathQueryRef(aPathQueryRef, nullptr); + NS_ENSURE_SUCCESS(mStatus, *this); + return *this; + } + NS_MutateURI& SetRef(const nsACString& aRef) + { + if (NS_FAILED(mStatus)) { + return *this; + } + mStatus = mMutator->SetRef(aRef, nullptr); + NS_ENSURE_SUCCESS(mStatus, *this); + return *this; + } + NS_MutateURI& SetFilePath(const nsACString& aFilePath) + { + if (NS_FAILED(mStatus)) { + return *this; + } + mStatus = mMutator->SetFilePath(aFilePath, nullptr); + NS_ENSURE_SUCCESS(mStatus, *this); + return *this; + } + NS_MutateURI& SetQuery(const nsACString& aQuery) + { + if (NS_FAILED(mStatus)) { + return *this; + } + mStatus = mMutator->SetQuery(aQuery, nullptr); + NS_ENSURE_SUCCESS(mStatus, *this); + return *this; + } + NS_MutateURI& SetQueryWithEncoding(const nsACString& query, const mozilla::Encoding *encoding) + { + if (NS_FAILED(mStatus)) { + return *this; + } + mStatus = mMutator->SetQueryWithEncoding(query, encoding, nullptr); + NS_ENSURE_SUCCESS(mStatus, *this); + return *this; + } + + /** + * This method allows consumers to call the methods declared in other + * interfaces implemented by the mutator object. + * + * Example: + * nsCOMPtr<nsIURI> uri; + * nsresult rv = NS_MutateURI(new URIClass::Mutator()) + * .SetSpec(aSpec) + * .Apply(NS_MutatorMethod(&SomeInterface::Method, arg1, arg2)) + * .Finalize(uri); + * + * If mMutator does not implement SomeInterface, do_QueryInterface will fail + * and the method will not be called. + * If aMethod does not exist, or if there is a mismatch between argument + * types, or the number of arguments, then there will be a compile error. + */ + NS_MutateURI& Apply(const std::function<nsresult(nsIURIMutator*)>& aFunction) + { + if (NS_FAILED(mStatus)) { + return *this; + } + mStatus = aFunction(mMutator); + return *this; + } + + template <class C> + [[nodiscard]] nsresult Finalize(nsCOMPtr<C>& aURI) + { + NS_ENSURE_SUCCESS(mStatus, mStatus); + + nsCOMPtr<nsIURI> uri; + mStatus = mMutator->Finalize(getter_AddRefs(uri)); + NS_ENSURE_SUCCESS(mStatus, mStatus); + + aURI = do_QueryInterface(uri, &mStatus); + NS_ENSURE_SUCCESS(mStatus, mStatus); + + mStatus = NS_ERROR_NOT_AVAILABLE; // Second call to Finalize should fail. + return NS_OK; + } + + // Overload for nsIURI to avoid query interface. + [[nodiscard]] nsresult Finalize(nsCOMPtr<nsIURI>& aURI) + { + if (NS_FAILED(mStatus)) return mStatus; + mStatus = mMutator->Finalize(getter_AddRefs(aURI)); + NS_ENSURE_SUCCESS(mStatus, mStatus); + + mStatus = NS_ERROR_NOT_AVAILABLE; // Second call to Finalize should fail. + return NS_OK; + } + + template <class C> + [[nodiscard]] nsresult Finalize(C** aURI) + { + NS_ENSURE_SUCCESS(mStatus, mStatus); + + nsCOMPtr<nsIURI> uri; + mStatus = mMutator->Finalize(getter_AddRefs(uri)); + NS_ENSURE_SUCCESS(mStatus, mStatus); + + nsCOMPtr<C> result = do_QueryInterface(uri, &mStatus); + NS_ENSURE_SUCCESS(mStatus, mStatus); + + result.forget(aURI); + mStatus = NS_ERROR_NOT_AVAILABLE; // Second call to Finalize should fail. + return NS_OK; + } + + [[nodiscard]] nsresult Finalize(nsIURI** aURI) + { + if (NS_FAILED(mStatus)) return mStatus; + mStatus = mMutator->Finalize(aURI); + NS_ENSURE_SUCCESS(mStatus, mStatus); + + mStatus = NS_ERROR_NOT_AVAILABLE; // Second call to Finalize should fail. + return NS_OK; + } + + nsresult GetStatus() { return mStatus; } +private: + nsresult mStatus; + nsCOMPtr<nsIURIMutator> mMutator; +}; + +%} diff --git a/netwerk/base/nsIURIMutatorUtils.cpp b/netwerk/base/nsIURIMutatorUtils.cpp new file mode 100644 index 0000000000..6c7fd7c92b --- /dev/null +++ b/netwerk/base/nsIURIMutatorUtils.cpp @@ -0,0 +1,27 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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 "nsIURIMutator.h" +#include "nsIURI.h" +#include "nsComponentManagerUtils.h" + +static nsresult GetURIMutator(nsIURI* aURI, nsIURIMutator** aMutator) { + if (NS_WARN_IF(!aURI)) { + return NS_ERROR_INVALID_ARG; + } + return aURI->Mutate(aMutator); +} + +NS_MutateURI::NS_MutateURI(nsIURI* aURI) { + mStatus = GetURIMutator(aURI, getter_AddRefs(mMutator)); + NS_ENSURE_SUCCESS_VOID(mStatus); +} + +NS_MutateURI::NS_MutateURI(const char* aContractID) + : mStatus(NS_ERROR_NOT_INITIALIZED) { + mMutator = do_CreateInstance(aContractID, &mStatus); + MOZ_ASSERT(NS_SUCCEEDED(mStatus), "Called with wrong aContractID"); +} diff --git a/netwerk/base/nsIURIWithSpecialOrigin.idl b/netwerk/base/nsIURIWithSpecialOrigin.idl new file mode 100644 index 0000000000..3b8e2e0c97 --- /dev/null +++ b/netwerk/base/nsIURIWithSpecialOrigin.idl @@ -0,0 +1,20 @@ +/* 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 "nsISupports.idl" + +interface nsIURI; + +/** + * nsIURIWithSpecialOrigin is implemented by URIs need to supply an origin that + * does not match the spec. This is exclusively used in comm-central's Mailnews module. + */ +[scriptable, builtinclass, uuid(4f65569b-d6fc-4580-94d9-21e775658a2a)] +interface nsIURIWithSpecialOrigin : nsISupports +{ + /** + * Special origin. + */ + readonly attribute nsIURI origin; +}; diff --git a/netwerk/base/nsIURL.idl b/netwerk/base/nsIURL.idl new file mode 100644 index 0000000000..11a9fa0f47 --- /dev/null +++ b/netwerk/base/nsIURL.idl @@ -0,0 +1,130 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsIURI.idl" +interface nsIURIMutator; + +/** + * The nsIURL interface provides convenience methods that further + * break down the path portion of nsIURI: + * + * http://host/directory/fileBaseName.fileExtension?query + * http://host/directory/fileBaseName.fileExtension#ref + * \ \ / + * \ ----------------------- + * \ | / + * \ fileName / + * ---------------------------- + * | + * filePath + */ +[scriptable, builtinclass, uuid(86adcd89-0b70-47a2-b0fe-5bb2c5f37e31)] +interface nsIURL : nsIURI +{ + /************************************************************************* + * The URL path is broken down into the following principal components: + * + * attribute AUTF8String filePath; + * attribute AUTF8String query; + * + * These are inherited from nsIURI. + */ + + /************************************************************************* + * The URL filepath is broken down into the following sub-components: + */ + + /** + * Returns the directory portion of a URL. If the URL denotes a path to a + * directory and not a file, e.g. http://host/foo/bar/, then the Directory + * attribute accesses the complete /foo/bar/ portion, and the FileName is + * the empty string. If the trailing slash is omitted, then the Directory + * is /foo/ and the file is bar (i.e. this is a syntactic, not a semantic + * breakdown of the Path). And hence don't rely on this for something to + * be a definitely be a file. But you can get just the leading directory + * portion for sure. + * + * Some characters may be escaped. + */ + readonly attribute AUTF8String directory; + + /** + * Returns the file name portion of a URL. If the URL denotes a path to a + * directory and not a file, e.g. http://host/foo/bar/, then the Directory + * attribute accesses the complete /foo/bar/ portion, and the FileName is + * the empty string. Note that this is purely based on searching for the + * last trailing slash. And hence don't rely on this to be a definite file. + * + * Some characters may be escaped. + */ + readonly attribute AUTF8String fileName; + + /************************************************************************* + * The URL filename is broken down even further: + */ + + /** + * Returns the file basename portion of a filename in a url. + * + * Some characters may be escaped. + */ + readonly attribute AUTF8String fileBaseName; + + /** + * Returns the file extension portion of a filename in a url. If a file + * extension does not exist, the empty string is returned. + * + * Some characters may be escaped. + */ + readonly attribute AUTF8String fileExtension; + + /** + * This method takes a uri and compares the two. The common uri portion + * is returned as a string. The minimum common uri portion is the + * protocol, and any of these if present: login, password, host and port + * If no commonality is found, "" is returned. If they are identical, the + * whole path with file/ref/etc. is returned. For file uris, it is + * expected that the common spec would be at least "file:///" since '/' is + * a shared common root. + * + * Examples: + * this.spec aURIToCompare.spec result + * 1) http://mozilla.org/ http://www.mozilla.org/ "" + * 2) http://foo.com/bar/ ftp://foo.com/bar/ "" + * 3) http://foo.com:8080/ http://foo.com/bar/ "" + * 4) ftp://user@foo.com/ ftp://user:pw@foo.com/ "" + * 5) ftp://foo.com/bar/ ftp://foo.com/bar ftp://foo.com/ + * 6) ftp://foo.com/bar/ ftp://foo.com/bar/b.html ftp://foo.com/bar/ + * 7) http://foo.com/a.htm#i http://foo.com/b.htm http://foo.com/ + * 8) ftp://foo.com/c.htm#i ftp://foo.com/c.htm ftp://foo.com/c.htm + * 9) file:///a/b/c.html file:///d/e/c.html file:/// + */ + AUTF8String getCommonBaseSpec(in nsIURI aURIToCompare); + + /** + * This method tries to create a string which specifies the location of the + * argument relative to |this|. If the argument and |this| are equal, the + * method returns "". If any of the URIs' scheme, host, userpass, or port + * don't match, the method returns the full spec of the argument. + * + * Examples: + * this.spec aURIToCompare.spec result + * 1) http://mozilla.org/ http://www.mozilla.org/ http://www.mozilla.org/ + * 2) http://mozilla.org/ http://www.mozilla.org http://www.mozilla.org/ + * 3) http://foo.com/bar/ http://foo.com:80/bar/ "" + * 4) http://foo.com/ http://foo.com/a.htm#b a.html#b + * 5) http://foo.com/a/b/ http://foo.com/c ../../c + */ + AUTF8String getRelativeSpec(in nsIURI aURIToCompare); + +}; + +[scriptable, builtinclass, uuid(25072eb8-f1e6-482f-9ca9-eddd3d65169a)] +interface nsIURLMutator : nsISupports +{ + [must_use] nsIURIMutator setFileName(in AUTF8String aFileName); + [must_use] nsIURIMutator setFileBaseName(in AUTF8String aFileBaseName); + [must_use] nsIURIMutator setFileExtension(in AUTF8String aFileExtension); +}; diff --git a/netwerk/base/nsIURLParser.idl b/netwerk/base/nsIURLParser.idl new file mode 100644 index 0000000000..3d6ac19b8c --- /dev/null +++ b/netwerk/base/nsIURLParser.idl @@ -0,0 +1,98 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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 "nsISupports.idl" + +/** + * nsIURLParser specifies the interface to an URL parser that attempts to + * follow the definitions of RFC 2396. + */ +[scriptable, uuid(78c5d19f-f5d2-4732-8d3d-d5a7d7133bc0)] +interface nsIURLParser : nsISupports +{ + /** + * The string to parse in the following methods may be given as a null + * terminated string, in which case the length argument should be -1. + * + * Out parameters of the following methods are all optional (ie. the caller + * may pass-in a NULL value if the corresponding results are not needed). + * Signed out parameters may hold a value of -1 if the corresponding result + * is not part of the string being parsed. + * + * The parsing routines attempt to be as forgiving as possible. + */ + + /** + * ParseSpec breaks the URL string up into its 3 major components: a scheme, + * an authority section (hostname, etc.), and a path. + * + * spec = <scheme>://<authority><path> + */ + void parseURL (in string spec, in long specLen, + out unsigned long schemePos, out long schemeLen, + out unsigned long authorityPos, out long authorityLen, + out unsigned long pathPos, out long pathLen); + + /** + * ParseAuthority breaks the authority string up into its 4 components: + * username, password, hostname, and hostport. + * + * auth = <username>:<password>@<hostname>:<port> + */ + void parseAuthority (in string authority, in long authorityLen, + out unsigned long usernamePos, out long usernameLen, + out unsigned long passwordPos, out long passwordLen, + out unsigned long hostnamePos, out long hostnameLen, + out long port); + + /** + * userinfo = <username>:<password> + */ + void parseUserInfo (in string userinfo, in long userinfoLen, + out unsigned long usernamePos, out long usernameLen, + out unsigned long passwordPos, out long passwordLen); + + /** + * serverinfo = <hostname>:<port> + */ + void parseServerInfo (in string serverinfo, in long serverinfoLen, + out unsigned long hostnamePos, out long hostnameLen, + out long port); + + /** + * ParsePath breaks the path string up into its 3 major components: a file path, + * a query string, and a reference string. + * + * path = <filepath>?<query>#<ref> + */ + void parsePath (in string path, in long pathLen, + out unsigned long filepathPos, out long filepathLen, + out unsigned long queryPos, out long queryLen, + out unsigned long refPos, out long refLen); + + /** + * ParseFilePath breaks the file path string up into: the directory portion, + * file base name, and file extension. + * + * filepath = <directory><basename>.<extension> + */ + void parseFilePath (in string filepath, in long filepathLen, + out unsigned long directoryPos, out long directoryLen, + out unsigned long basenamePos, out long basenameLen, + out unsigned long extensionPos, out long extensionLen); + + /** + * filename = <basename>.<extension> + */ + void parseFileName (in string filename, in long filenameLen, + out unsigned long basenamePos, out long basenameLen, + out unsigned long extensionPos, out long extensionLen); +}; + +%{C++ +// url parser key for use with the category manager +// mapping from scheme to url parser. +#define NS_IURLPARSER_KEY "@mozilla.org/urlparser;1" +%} diff --git a/netwerk/base/nsIUploadChannel.idl b/netwerk/base/nsIUploadChannel.idl new file mode 100644 index 0000000000..1c059e8869 --- /dev/null +++ b/netwerk/base/nsIUploadChannel.idl @@ -0,0 +1,56 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "nsISupports.idl" + +interface nsIInputStream; + +/** + * nsIUploadChannel + * + * A channel may optionally implement this interface if it supports the + * notion of uploading a data stream. The upload stream may only be set + * prior to the invocation of asyncOpen on the channel. + */ +[scriptable, uuid(5cfe15bd-5adb-4a7f-9e55-4f5a67d15794)] +interface nsIUploadChannel : nsISupports +{ + /** + * Sets a stream to be uploaded by this channel. + * + * Most implementations of this interface require that the stream: + * (1) implement threadsafe addRef and release + * (2) implement nsIInputStream::readSegments + * (3) implement nsISeekableStream::seek + * + * History here is that we need to support both streams that already have + * headers (e.g., Content-Type and Content-Length) information prepended to + * the stream (by plugins) as well as clients (composer, uploading + * application) that want to upload data streams without any knowledge of + * protocol specifications. For this reason, we have a special meaning + * for the aContentType parameter (see below). + * + * @param aStream + * The stream to be uploaded by this channel. + * @param aContentType + * If aContentType is empty, the protocol will assume that no + * content headers are to be added to the uploaded stream and that + * any required headers are already encoded in the stream. In the + * case of HTTP, if this parameter is non-empty, then its value will + * replace any existing Content-Type header on the HTTP request. + * In the case of FTP and FILE, this parameter is ignored. + * @param aContentLength + * A value of -1 indicates that the length of the stream should be + * determined by calling the stream's |available| method. + */ + void setUploadStream(in nsIInputStream aStream, + in ACString aContentType, + in long long aContentLength); + + /** + * Get the stream (to be) uploaded by this channel. + */ + readonly attribute nsIInputStream uploadStream; +}; diff --git a/netwerk/base/nsIUploadChannel2.idl b/netwerk/base/nsIUploadChannel2.idl new file mode 100644 index 0000000000..abbfb1b781 --- /dev/null +++ b/netwerk/base/nsIUploadChannel2.idl @@ -0,0 +1,69 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "nsISupports.idl" + +interface nsIInputStream; +interface nsIRunnable; + +[scriptable, uuid(2f712b52-19c5-4e0c-9e8f-b5c7c3b67049)] +interface nsIUploadChannel2 : nsISupports +{ + /** + * Sets a stream to be uploaded by this channel with the specified + * Content-Type and Content-Length header values. + * + * Most implementations of this interface require that the stream: + * (1) implement threadsafe addRef and release + * (2) implement nsIInputStream::readSegments + * (3) implement nsISeekableStream::seek + * + * @param aStream + * The stream to be uploaded by this channel. + * @param aContentType + * This value will replace any existing Content-Type + * header on the HTTP request, regardless of whether + * or not its empty. + * @param aContentLength + * A value of -1 indicates that the length of the stream should be + * determined by calling the stream's |available| method. + * @param aMethod + * The HTTP request method to set on the stream. + * @param aStreamHasHeaders + * True if the stream already contains headers for the HTTP request. + */ + void explicitSetUploadStream(in nsIInputStream aStream, + in ACString aContentType, + in long long aContentLength, + in ACString aMethod, + in boolean aStreamHasHeaders); + + /** + * Value of aStreamHasHeaders from the last successful call to + * explicitSetUploadStream. TRUE indicates the attached upload stream + * contains request headers. + */ + readonly attribute boolean uploadStreamHasHeaders; + + /** + * Ensure the upload stream, if any, is cloneable. This may involve + * async copying, so a callback runnable must be provided. It will + * invoked on the current thread when the upload stream is ready + * for cloning. If the stream is already cloneable, then the callback + * will be invoked synchronously. + */ + [noscript] + void ensureUploadStreamIsCloneable(in nsIRunnable aCallback); + + /** + * Clones the upload stream. May return failure if the upload stream + * is not cloneable. If this is not acceptable, use the + * ensureUploadStreamIsCloneable() method first. + * aContentLength could be -1 in case the size of the stream is unknown, + * otherwise it will contain the known size of the stream. + */ + [noscript] + nsIInputStream cloneUploadStream(out long long aContentLength); +}; diff --git a/netwerk/base/nsIncrementalDownload.cpp b/netwerk/base/nsIncrementalDownload.cpp new file mode 100644 index 0000000000..c9fb767f94 --- /dev/null +++ b/netwerk/base/nsIncrementalDownload.cpp @@ -0,0 +1,832 @@ +/* -*- 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 "mozilla/Attributes.h" +#include "mozilla/UniquePtrExtensions.h" +#include "mozilla/UniquePtr.h" + +#include "nsIIncrementalDownload.h" +#include "nsIRequestObserver.h" +#include "nsIProgressEventSink.h" +#include "nsIChannelEventSink.h" +#include "nsIAsyncVerifyRedirectCallback.h" +#include "nsIInterfaceRequestor.h" +#include "nsIObserverService.h" +#include "nsIObserver.h" +#include "nsIStreamListener.h" +#include "nsIFile.h" +#include "nsIHttpChannel.h" +#include "nsITimer.h" +#include "nsIURI.h" +#include "nsIInputStream.h" +#include "nsNetUtil.h" +#include "nsWeakReference.h" +#include "prio.h" +#include "prprf.h" +#include <algorithm> +#include "nsIContentPolicy.h" +#include "nsContentUtils.h" +#include "mozilla/UniquePtr.h" + +// Default values used to initialize a nsIncrementalDownload object. +#define DEFAULT_CHUNK_SIZE (4096 * 16) // bytes +#define DEFAULT_INTERVAL 60 // seconds + +#define UPDATE_PROGRESS_INTERVAL PRTime(100 * PR_USEC_PER_MSEC) // 100ms + +// Number of times to retry a failed byte-range request. +#define MAX_RETRY_COUNT 20 + +using namespace mozilla; +using namespace mozilla::net; + +//----------------------------------------------------------------------------- + +static nsresult WriteToFile(nsIFile* lf, const char* data, uint32_t len, + int32_t flags) { + PRFileDesc* fd; + int32_t mode = 0600; + nsresult rv; + rv = lf->OpenNSPRFileDesc(flags, mode, &fd); + if (NS_FAILED(rv)) return rv; + + if (len) + rv = PR_Write(fd, data, len) == int32_t(len) ? NS_OK : NS_ERROR_FAILURE; + + PR_Close(fd); + return rv; +} + +static nsresult AppendToFile(nsIFile* lf, const char* data, uint32_t len) { + int32_t flags = PR_WRONLY | PR_CREATE_FILE | PR_APPEND; + return WriteToFile(lf, data, len, flags); +} + +// maxSize may be -1 if unknown +static void MakeRangeSpec(const int64_t& size, const int64_t& maxSize, + int32_t chunkSize, bool fetchRemaining, + nsCString& rangeSpec) { + rangeSpec.AssignLiteral("bytes="); + rangeSpec.AppendInt(int64_t(size)); + rangeSpec.Append('-'); + + if (fetchRemaining) return; + + int64_t end = size + int64_t(chunkSize); + if (maxSize != int64_t(-1) && end > maxSize) end = maxSize; + end -= 1; + + rangeSpec.AppendInt(int64_t(end)); +} + +//----------------------------------------------------------------------------- + +class nsIncrementalDownload final : public nsIIncrementalDownload, + public nsIStreamListener, + public nsIObserver, + public nsIInterfaceRequestor, + public nsIChannelEventSink, + public nsSupportsWeakReference, + public nsIAsyncVerifyRedirectCallback { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIREQUEST + NS_DECL_NSIINCREMENTALDOWNLOAD + NS_DECL_NSIREQUESTOBSERVER + NS_DECL_NSISTREAMLISTENER + NS_DECL_NSIOBSERVER + NS_DECL_NSIINTERFACEREQUESTOR + NS_DECL_NSICHANNELEVENTSINK + NS_DECL_NSIASYNCVERIFYREDIRECTCALLBACK + + nsIncrementalDownload(); + + private: + ~nsIncrementalDownload() = default; + nsresult FlushChunk(); + void UpdateProgress(); + nsresult CallOnStartRequest(); + void CallOnStopRequest(); + nsresult StartTimer(int32_t interval); + nsresult ProcessTimeout(); + nsresult ReadCurrentSize(); + nsresult ClearRequestHeader(nsIHttpChannel* channel); + + nsCOMPtr<nsIRequestObserver> mObserver; + nsCOMPtr<nsIProgressEventSink> mProgressSink; + nsCOMPtr<nsIURI> mURI; + nsCOMPtr<nsIURI> mFinalURI; + nsCOMPtr<nsIFile> mDest; + nsCOMPtr<nsIChannel> mChannel; + nsCOMPtr<nsITimer> mTimer; + mozilla::UniquePtr<char[]> mChunk; + int32_t mChunkLen; + int32_t mChunkSize; + int32_t mInterval; + int64_t mTotalSize; + int64_t mCurrentSize; + uint32_t mLoadFlags; + int32_t mNonPartialCount; + nsresult mStatus; + bool mIsPending; + bool mDidOnStartRequest; + PRTime mLastProgressUpdate; + nsCOMPtr<nsIAsyncVerifyRedirectCallback> mRedirectCallback; + nsCOMPtr<nsIChannel> mNewRedirectChannel; + nsCString mPartialValidator; + bool mCacheBust; +}; + +nsIncrementalDownload::nsIncrementalDownload() + : mChunkLen(0), + mChunkSize(DEFAULT_CHUNK_SIZE), + mInterval(DEFAULT_INTERVAL), + mTotalSize(-1), + mCurrentSize(-1), + mLoadFlags(LOAD_NORMAL), + mNonPartialCount(0), + mStatus(NS_OK), + mIsPending(false), + mDidOnStartRequest(false), + mLastProgressUpdate(0), + mRedirectCallback(nullptr), + mNewRedirectChannel(nullptr), + mCacheBust(false) {} + +nsresult nsIncrementalDownload::FlushChunk() { + NS_ASSERTION(mTotalSize != int64_t(-1), "total size should be known"); + + if (mChunkLen == 0) return NS_OK; + + nsresult rv = AppendToFile(mDest, mChunk.get(), mChunkLen); + if (NS_FAILED(rv)) return rv; + + mCurrentSize += int64_t(mChunkLen); + mChunkLen = 0; + + return NS_OK; +} + +void nsIncrementalDownload::UpdateProgress() { + mLastProgressUpdate = PR_Now(); + + if (mProgressSink) + mProgressSink->OnProgress(this, mCurrentSize + mChunkLen, mTotalSize); +} + +nsresult nsIncrementalDownload::CallOnStartRequest() { + if (!mObserver || mDidOnStartRequest) return NS_OK; + + mDidOnStartRequest = true; + return mObserver->OnStartRequest(this); +} + +void nsIncrementalDownload::CallOnStopRequest() { + if (!mObserver) return; + + // Ensure that OnStartRequest is always called once before OnStopRequest. + nsresult rv = CallOnStartRequest(); + if (NS_SUCCEEDED(mStatus)) mStatus = rv; + + mIsPending = false; + + mObserver->OnStopRequest(this, mStatus); + mObserver = nullptr; +} + +nsresult nsIncrementalDownload::StartTimer(int32_t interval) { + return NS_NewTimerWithObserver(getter_AddRefs(mTimer), this, interval * 1000, + nsITimer::TYPE_ONE_SHOT); +} + +nsresult nsIncrementalDownload::ProcessTimeout() { + NS_ASSERTION(!mChannel, "how can we have a channel?"); + + // Handle existing error conditions + if (NS_FAILED(mStatus)) { + CallOnStopRequest(); + return NS_OK; + } + + // Fetch next chunk + + nsCOMPtr<nsIChannel> channel; + nsresult rv = NS_NewChannel( + getter_AddRefs(channel), mFinalURI, nsContentUtils::GetSystemPrincipal(), + nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL, + nsIContentPolicy::TYPE_OTHER, + nullptr, // nsICookieJarSettings + nullptr, // PerformanceStorage + nullptr, // loadGroup + this, // aCallbacks + mLoadFlags); + + if (NS_FAILED(rv)) return rv; + + nsCOMPtr<nsIHttpChannel> http = do_QueryInterface(channel, &rv); + if (NS_FAILED(rv)) return rv; + + NS_ASSERTION(mCurrentSize != int64_t(-1), + "we should know the current file size by now"); + + rv = ClearRequestHeader(http); + if (NS_FAILED(rv)) return rv; + + // Don't bother making a range request if we are just going to fetch the + // entire document. + if (mInterval || mCurrentSize != int64_t(0)) { + nsAutoCString range; + MakeRangeSpec(mCurrentSize, mTotalSize, mChunkSize, mInterval == 0, range); + + rv = http->SetRequestHeader("Range"_ns, range, false); + if (NS_FAILED(rv)) return rv; + + if (!mPartialValidator.IsEmpty()) { + rv = http->SetRequestHeader("If-Range"_ns, mPartialValidator, false); + if (NS_FAILED(rv)) { + LOG( + ("nsIncrementalDownload::ProcessTimeout\n" + " failed to set request header: If-Range\n")); + } + } + + if (mCacheBust) { + rv = http->SetRequestHeader("Cache-Control"_ns, "no-cache"_ns, false); + if (NS_FAILED(rv)) { + LOG( + ("nsIncrementalDownload::ProcessTimeout\n" + " failed to set request header: If-Range\n")); + } + rv = http->SetRequestHeader("Pragma"_ns, "no-cache"_ns, false); + if (NS_FAILED(rv)) { + LOG( + ("nsIncrementalDownload::ProcessTimeout\n" + " failed to set request header: If-Range\n")); + } + } + } + + rv = channel->AsyncOpen(this); + if (NS_FAILED(rv)) return rv; + + // Wait to assign mChannel when we know we are going to succeed. This is + // important because we don't want to introduce a reference cycle between + // mChannel and this until we know for a fact that AsyncOpen has succeeded, + // thus ensuring that our stream listener methods will be invoked. + mChannel = channel; + return NS_OK; +} + +// Reads the current file size and validates it. +nsresult nsIncrementalDownload::ReadCurrentSize() { + int64_t size; + nsresult rv = mDest->GetFileSize((int64_t*)&size); + if (rv == NS_ERROR_FILE_NOT_FOUND || + rv == NS_ERROR_FILE_TARGET_DOES_NOT_EXIST) { + mCurrentSize = 0; + return NS_OK; + } + if (NS_FAILED(rv)) return rv; + + mCurrentSize = size; + return NS_OK; +} + +// nsISupports + +NS_IMPL_ISUPPORTS(nsIncrementalDownload, nsIIncrementalDownload, nsIRequest, + nsIStreamListener, nsIRequestObserver, nsIObserver, + nsIInterfaceRequestor, nsIChannelEventSink, + nsISupportsWeakReference, nsIAsyncVerifyRedirectCallback) + +// nsIRequest + +NS_IMETHODIMP +nsIncrementalDownload::GetName(nsACString& name) { + NS_ENSURE_TRUE(mURI, NS_ERROR_NOT_INITIALIZED); + + return mURI->GetSpec(name); +} + +NS_IMETHODIMP +nsIncrementalDownload::IsPending(bool* isPending) { + *isPending = mIsPending; + return NS_OK; +} + +NS_IMETHODIMP +nsIncrementalDownload::GetStatus(nsresult* status) { + *status = mStatus; + return NS_OK; +} + +NS_IMETHODIMP +nsIncrementalDownload::Cancel(nsresult status) { + NS_ENSURE_ARG(NS_FAILED(status)); + + // Ignore this cancelation if we're already canceled. + if (NS_FAILED(mStatus)) return NS_OK; + + mStatus = status; + + // Nothing more to do if callbacks aren't pending. + if (!mIsPending) return NS_OK; + + if (mChannel) { + mChannel->Cancel(mStatus); + NS_ASSERTION(!mTimer, "what is this timer object doing here?"); + } else { + // dispatch a timer callback event to drive invoking our listener's + // OnStopRequest. + if (mTimer) mTimer->Cancel(); + StartTimer(0); + } + + return NS_OK; +} + +NS_IMETHODIMP +nsIncrementalDownload::Suspend() { return NS_ERROR_NOT_IMPLEMENTED; } + +NS_IMETHODIMP +nsIncrementalDownload::Resume() { return NS_ERROR_NOT_IMPLEMENTED; } + +NS_IMETHODIMP +nsIncrementalDownload::GetLoadFlags(nsLoadFlags* loadFlags) { + *loadFlags = mLoadFlags; + return NS_OK; +} + +NS_IMETHODIMP +nsIncrementalDownload::SetLoadFlags(nsLoadFlags loadFlags) { + mLoadFlags = loadFlags; + return NS_OK; +} + +NS_IMETHODIMP +nsIncrementalDownload::GetTRRMode(nsIRequest::TRRMode* aTRRMode) { + return GetTRRModeImpl(aTRRMode); +} + +NS_IMETHODIMP +nsIncrementalDownload::SetTRRMode(nsIRequest::TRRMode aTRRMode) { + return SetTRRModeImpl(aTRRMode); +} + +NS_IMETHODIMP +nsIncrementalDownload::GetLoadGroup(nsILoadGroup** loadGroup) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsIncrementalDownload::SetLoadGroup(nsILoadGroup* loadGroup) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +// nsIIncrementalDownload + +NS_IMETHODIMP +nsIncrementalDownload::Init(nsIURI* uri, nsIFile* dest, int32_t chunkSize, + int32_t interval) { + // Keep it simple: only allow initialization once + NS_ENSURE_FALSE(mURI, NS_ERROR_ALREADY_INITIALIZED); + + mDest = dest; + NS_ENSURE_ARG(mDest); + + mURI = uri; + mFinalURI = uri; + + if (chunkSize > 0) mChunkSize = chunkSize; + if (interval >= 0) mInterval = interval; + return NS_OK; +} + +NS_IMETHODIMP +nsIncrementalDownload::GetURI(nsIURI** result) { + nsCOMPtr<nsIURI> uri = mURI; + uri.forget(result); + return NS_OK; +} + +NS_IMETHODIMP +nsIncrementalDownload::GetFinalURI(nsIURI** result) { + nsCOMPtr<nsIURI> uri = mFinalURI; + uri.forget(result); + return NS_OK; +} + +NS_IMETHODIMP +nsIncrementalDownload::GetDestination(nsIFile** result) { + if (!mDest) { + *result = nullptr; + return NS_OK; + } + // Return a clone of mDest so that callers may modify the resulting nsIFile + // without corrupting our internal object. This also works around the fact + // that some nsIFile impls may cache the result of stat'ing the filesystem. + return mDest->Clone(result); +} + +NS_IMETHODIMP +nsIncrementalDownload::GetTotalSize(int64_t* result) { + *result = mTotalSize; + return NS_OK; +} + +NS_IMETHODIMP +nsIncrementalDownload::GetCurrentSize(int64_t* result) { + *result = mCurrentSize; + return NS_OK; +} + +NS_IMETHODIMP +nsIncrementalDownload::Start(nsIRequestObserver* observer, + nsISupports* context) { + NS_ENSURE_ARG(observer); + NS_ENSURE_FALSE(mIsPending, NS_ERROR_IN_PROGRESS); + + // Observe system shutdown so we can be sure to release any reference held + // between ourselves and the timer. We have the observer service hold a weak + // reference to us, so that we don't have to worry about calling + // RemoveObserver. XXX(darin): The timer code should do this for us. + nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); + if (obs) obs->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, true); + + nsresult rv = ReadCurrentSize(); + if (NS_FAILED(rv)) return rv; + + rv = StartTimer(0); + if (NS_FAILED(rv)) return rv; + + mObserver = observer; + mProgressSink = do_QueryInterface(observer); // ok if null + + mIsPending = true; + return NS_OK; +} + +// nsIRequestObserver + +NS_IMETHODIMP +nsIncrementalDownload::OnStartRequest(nsIRequest* request) { + nsresult rv; + + nsCOMPtr<nsIHttpChannel> http = do_QueryInterface(request, &rv); + if (NS_FAILED(rv)) return rv; + + // Ensure that we are receiving a 206 response. + uint32_t code; + rv = http->GetResponseStatus(&code); + if (NS_FAILED(rv)) return rv; + if (code != 206) { + // We may already have the entire file downloaded, in which case + // our request for a range beyond the end of the file would have + // been met with an error response code. + if (code == 416 && mTotalSize == int64_t(-1)) { + mTotalSize = mCurrentSize; + // Return an error code here to suppress OnDataAvailable. + return NS_ERROR_DOWNLOAD_COMPLETE; + } + // The server may have decided to give us all of the data in one chunk. If + // we requested a partial range, then we don't want to download all of the + // data at once. So, we'll just try again, but if this keeps happening then + // we'll eventually give up. + if (code == 200) { + if (mInterval) { + mChannel = nullptr; + if (++mNonPartialCount > MAX_RETRY_COUNT) { + NS_WARNING("unable to fetch a byte range; giving up"); + return NS_ERROR_FAILURE; + } + // Increase delay with each failure. + StartTimer(mInterval * mNonPartialCount); + return NS_ERROR_DOWNLOAD_NOT_PARTIAL; + } + // Since we have been asked to download the rest of the file, we can deal + // with a 200 response. This may result in downloading the beginning of + // the file again, but that can't really be helped. + } else { + NS_WARNING("server response was unexpected"); + return NS_ERROR_UNEXPECTED; + } + } else { + // We got a partial response, so clear this counter in case the next chunk + // results in a 200 response. + mNonPartialCount = 0; + + // confirm that the content-range response header is consistent with + // expectations on each 206. If it is not then drop this response and + // retry with no-cache set. + if (!mCacheBust) { + nsAutoCString buf; + int64_t startByte = 0; + bool confirmedOK = false; + + rv = http->GetResponseHeader("Content-Range"_ns, buf); + if (NS_FAILED(rv)) + return rv; // it isn't a useful 206 without a CONTENT-RANGE of some + // sort + + // Content-Range: bytes 0-299999/25604694 + int32_t p = buf.Find("bytes "); + + // first look for the starting point of the content-range + // to make sure it is what we expect + if (p != -1) { + char* endptr = nullptr; + const char* s = buf.get() + p + 6; + while (*s && *s == ' ') s++; + startByte = strtol(s, &endptr, 10); + + if (*s && endptr && (endptr != s) && (mCurrentSize == startByte)) { + // ok the starting point is confirmed. We still need to check the + // total size of the range for consistency if this isn't + // the first chunk + if (mTotalSize == int64_t(-1)) { + // first chunk + confirmedOK = true; + } else { + int32_t slash = buf.FindChar('/'); + int64_t rangeSize = 0; + if (slash != kNotFound && + (PR_sscanf(buf.get() + slash + 1, "%lld", + (int64_t*)&rangeSize) == 1) && + rangeSize == mTotalSize) { + confirmedOK = true; + } + } + } + } + + if (!confirmedOK) { + NS_WARNING("unexpected content-range"); + mCacheBust = true; + mChannel = nullptr; + if (++mNonPartialCount > MAX_RETRY_COUNT) { + NS_WARNING("unable to fetch a byte range; giving up"); + return NS_ERROR_FAILURE; + } + // Increase delay with each failure. + StartTimer(mInterval * mNonPartialCount); + return NS_ERROR_DOWNLOAD_NOT_PARTIAL; + } + } + } + + // Do special processing after the first response. + if (mTotalSize == int64_t(-1)) { + // Update knowledge of mFinalURI + rv = http->GetURI(getter_AddRefs(mFinalURI)); + if (NS_FAILED(rv)) return rv; + Unused << http->GetResponseHeader("Etag"_ns, mPartialValidator); + if (StringBeginsWith(mPartialValidator, "W/"_ns)) + mPartialValidator.Truncate(); // don't use weak validators + if (mPartialValidator.IsEmpty()) { + rv = http->GetResponseHeader("Last-Modified"_ns, mPartialValidator); + if (NS_FAILED(rv)) { + LOG( + ("nsIncrementalDownload::OnStartRequest\n" + " empty validator\n")); + } + } + + if (code == 206) { + // OK, read the Content-Range header to determine the total size of this + // download file. + nsAutoCString buf; + rv = http->GetResponseHeader("Content-Range"_ns, buf); + if (NS_FAILED(rv)) return rv; + int32_t slash = buf.FindChar('/'); + if (slash == kNotFound) { + NS_WARNING("server returned invalid Content-Range header!"); + return NS_ERROR_UNEXPECTED; + } + if (PR_sscanf(buf.get() + slash + 1, "%lld", (int64_t*)&mTotalSize) != 1) + return NS_ERROR_UNEXPECTED; + } else { + rv = http->GetContentLength(&mTotalSize); + if (NS_FAILED(rv)) return rv; + // We need to know the total size of the thing we're trying to download. + if (mTotalSize == int64_t(-1)) { + NS_WARNING("server returned no content-length header!"); + return NS_ERROR_UNEXPECTED; + } + // Need to truncate (or create, if it doesn't exist) the file since we + // are downloading the whole thing. + WriteToFile(mDest, nullptr, 0, PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE); + mCurrentSize = 0; + } + + // Notify observer that we are starting... + rv = CallOnStartRequest(); + if (NS_FAILED(rv)) return rv; + } + + // Adjust mChunkSize accordingly if mCurrentSize is close to mTotalSize. + int64_t diff = mTotalSize - mCurrentSize; + if (diff <= int64_t(0)) { + NS_WARNING("about to set a bogus chunk size; giving up"); + return NS_ERROR_UNEXPECTED; + } + + if (diff < int64_t(mChunkSize)) mChunkSize = uint32_t(diff); + + mChunk = mozilla::MakeUniqueFallible<char[]>(mChunkSize); + if (!mChunk) rv = NS_ERROR_OUT_OF_MEMORY; + + return rv; +} + +NS_IMETHODIMP +nsIncrementalDownload::OnStopRequest(nsIRequest* request, nsresult status) { + // Not a real error; just a trick to kill off the channel without our + // listener having to care. + if (status == NS_ERROR_DOWNLOAD_NOT_PARTIAL) return NS_OK; + + // Not a real error; just a trick used to suppress OnDataAvailable calls. + if (status == NS_ERROR_DOWNLOAD_COMPLETE) status = NS_OK; + + if (NS_SUCCEEDED(mStatus)) mStatus = status; + + if (mChunk) { + if (NS_SUCCEEDED(mStatus)) mStatus = FlushChunk(); + + mChunk = nullptr; // deletes memory + mChunkLen = 0; + UpdateProgress(); + } + + mChannel = nullptr; + + // Notify listener if we hit an error or finished + if (NS_FAILED(mStatus) || mCurrentSize == mTotalSize) { + CallOnStopRequest(); + return NS_OK; + } + + return StartTimer(mInterval); // Do next chunk +} + +// nsIStreamListener + +NS_IMETHODIMP +nsIncrementalDownload::OnDataAvailable(nsIRequest* request, + nsIInputStream* input, uint64_t offset, + uint32_t count) { + while (count) { + uint32_t space = mChunkSize - mChunkLen; + uint32_t n, len = std::min(space, count); + + nsresult rv = input->Read(&mChunk[mChunkLen], len, &n); + if (NS_FAILED(rv)) return rv; + if (n != len) return NS_ERROR_UNEXPECTED; + + count -= n; + mChunkLen += n; + + if (mChunkLen == mChunkSize) { + rv = FlushChunk(); + if (NS_FAILED(rv)) return rv; + } + } + + if (PR_Now() > mLastProgressUpdate + UPDATE_PROGRESS_INTERVAL) + UpdateProgress(); + + return NS_OK; +} + +// nsIObserver + +NS_IMETHODIMP +nsIncrementalDownload::Observe(nsISupports* subject, const char* topic, + const char16_t* data) { + if (strcmp(topic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0) { + Cancel(NS_ERROR_ABORT); + + // Since the app is shutting down, we need to go ahead and notify our + // observer here. Otherwise, we would notify them after XPCOM has been + // shutdown or not at all. + CallOnStopRequest(); + } else if (strcmp(topic, NS_TIMER_CALLBACK_TOPIC) == 0) { + mTimer = nullptr; + nsresult rv = ProcessTimeout(); + if (NS_FAILED(rv)) Cancel(rv); + } + return NS_OK; +} + +// nsIInterfaceRequestor + +NS_IMETHODIMP +nsIncrementalDownload::GetInterface(const nsIID& iid, void** result) { + if (iid.Equals(NS_GET_IID(nsIChannelEventSink))) { + NS_ADDREF_THIS(); + *result = static_cast<nsIChannelEventSink*>(this); + return NS_OK; + } + + nsCOMPtr<nsIInterfaceRequestor> ir = do_QueryInterface(mObserver); + if (ir) return ir->GetInterface(iid, result); + + return NS_ERROR_NO_INTERFACE; +} + +nsresult nsIncrementalDownload::ClearRequestHeader(nsIHttpChannel* channel) { + NS_ENSURE_ARG(channel); + + // We don't support encodings -- they make the Content-Length not equal + // to the actual size of the data. + return channel->SetRequestHeader("Accept-Encoding"_ns, ""_ns, false); +} + +// nsIChannelEventSink + +NS_IMETHODIMP +nsIncrementalDownload::AsyncOnChannelRedirect( + nsIChannel* oldChannel, nsIChannel* newChannel, uint32_t flags, + nsIAsyncVerifyRedirectCallback* cb) { + // In response to a redirect, we need to propagate the Range header. See bug + // 311595. Any failure code returned from this function aborts the redirect. + + nsCOMPtr<nsIHttpChannel> http = do_QueryInterface(oldChannel); + NS_ENSURE_STATE(http); + + nsCOMPtr<nsIHttpChannel> newHttpChannel = do_QueryInterface(newChannel); + NS_ENSURE_STATE(newHttpChannel); + + constexpr auto rangeHdr = "Range"_ns; + + nsresult rv = ClearRequestHeader(newHttpChannel); + if (NS_FAILED(rv)) return rv; + + // If we didn't have a Range header, then we must be doing a full download. + nsAutoCString rangeVal; + Unused << http->GetRequestHeader(rangeHdr, rangeVal); + if (!rangeVal.IsEmpty()) { + rv = newHttpChannel->SetRequestHeader(rangeHdr, rangeVal, false); + NS_ENSURE_SUCCESS(rv, rv); + } + + // A redirection changes the validator + mPartialValidator.Truncate(); + + if (mCacheBust) { + rv = newHttpChannel->SetRequestHeader("Cache-Control"_ns, "no-cache"_ns, + false); + if (NS_FAILED(rv)) { + LOG( + ("nsIncrementalDownload::AsyncOnChannelRedirect\n" + " failed to set request header: Cache-Control\n")); + } + rv = newHttpChannel->SetRequestHeader("Pragma"_ns, "no-cache"_ns, false); + if (NS_FAILED(rv)) { + LOG( + ("nsIncrementalDownload::AsyncOnChannelRedirect\n" + " failed to set request header: Pragma\n")); + } + } + + // Prepare to receive callback + mRedirectCallback = cb; + mNewRedirectChannel = newChannel; + + // Give the observer a chance to see this redirect notification. + nsCOMPtr<nsIChannelEventSink> sink = do_GetInterface(mObserver); + if (sink) { + rv = sink->AsyncOnChannelRedirect(oldChannel, newChannel, flags, this); + if (NS_FAILED(rv)) { + mRedirectCallback = nullptr; + mNewRedirectChannel = nullptr; + } + return rv; + } + (void)OnRedirectVerifyCallback(NS_OK); + return NS_OK; +} + +NS_IMETHODIMP +nsIncrementalDownload::OnRedirectVerifyCallback(nsresult result) { + NS_ASSERTION(mRedirectCallback, "mRedirectCallback not set in callback"); + NS_ASSERTION(mNewRedirectChannel, "mNewRedirectChannel not set in callback"); + + // Update mChannel, so we can Cancel the new channel. + if (NS_SUCCEEDED(result)) mChannel = mNewRedirectChannel; + + mRedirectCallback->OnRedirectVerifyCallback(result); + mRedirectCallback = nullptr; + mNewRedirectChannel = nullptr; + return NS_OK; +} + +extern nsresult net_NewIncrementalDownload(nsISupports* outer, const nsIID& iid, + void** result) { + if (outer) return NS_ERROR_NO_AGGREGATION; + + RefPtr<nsIncrementalDownload> d = new nsIncrementalDownload(); + return d->QueryInterface(iid, result); +} diff --git a/netwerk/base/nsIncrementalStreamLoader.cpp b/netwerk/base/nsIncrementalStreamLoader.cpp new file mode 100644 index 0000000000..00fb7aeb03 --- /dev/null +++ b/netwerk/base/nsIncrementalStreamLoader.cpp @@ -0,0 +1,188 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "nsIncrementalStreamLoader.h" +#include "nsIInputStream.h" +#include "nsIChannel.h" +#include "nsError.h" +#include "GeckoProfiler.h" + +#include <limits> + +nsIncrementalStreamLoader::nsIncrementalStreamLoader() = default; + +NS_IMETHODIMP +nsIncrementalStreamLoader::Init(nsIIncrementalStreamLoaderObserver* observer) { + NS_ENSURE_ARG_POINTER(observer); + mObserver = observer; + return NS_OK; +} + +nsresult nsIncrementalStreamLoader::Create(nsISupports* aOuter, REFNSIID aIID, + void** aResult) { + if (aOuter) return NS_ERROR_NO_AGGREGATION; + + RefPtr<nsIncrementalStreamLoader> it = new nsIncrementalStreamLoader(); + return it->QueryInterface(aIID, aResult); +} + +NS_IMPL_ISUPPORTS(nsIncrementalStreamLoader, nsIIncrementalStreamLoader, + nsIRequestObserver, nsIStreamListener, + nsIThreadRetargetableStreamListener) + +NS_IMETHODIMP +nsIncrementalStreamLoader::GetNumBytesRead(uint32_t* aNumBytes) { + *aNumBytes = mBytesRead; + return NS_OK; +} + +/* readonly attribute nsIRequest request; */ +NS_IMETHODIMP +nsIncrementalStreamLoader::GetRequest(nsIRequest** aRequest) { + NS_IF_ADDREF(*aRequest = mRequest); + return NS_OK; +} + +NS_IMETHODIMP +nsIncrementalStreamLoader::OnStartRequest(nsIRequest* request) { + nsCOMPtr<nsIChannel> chan(do_QueryInterface(request)); + if (chan) { + int64_t contentLength = -1; + chan->GetContentLength(&contentLength); + if (contentLength >= 0) { + // On 64bit platforms size of uint64_t coincides with the size of size_t, + // so we want to compare with the minimum from size_t and int64_t. + if (static_cast<uint64_t>(contentLength) > + std::min(std::numeric_limits<size_t>::max(), + static_cast<size_t>(std::numeric_limits<int64_t>::max()))) { + // Too big to fit into size_t, so let's bail. + return NS_ERROR_OUT_OF_MEMORY; + } + + // preallocate buffer + if (!mData.initCapacity(contentLength)) { + return NS_ERROR_OUT_OF_MEMORY; + } + } + } + return NS_OK; +} + +NS_IMETHODIMP +nsIncrementalStreamLoader::OnStopRequest(nsIRequest* request, + nsresult aStatus) { + AUTO_PROFILER_LABEL("nsIncrementalStreamLoader::OnStopRequest", NETWORK); + + if (mObserver) { + // provide nsIIncrementalStreamLoader::request during call to + // OnStreamComplete + mRequest = request; + size_t length = mData.length(); + uint8_t* elems = mData.extractOrCopyRawBuffer(); + nsresult rv = + mObserver->OnStreamComplete(this, mContext, aStatus, length, elems); + if (rv != NS_SUCCESS_ADOPTED_DATA) { + // The observer didn't take ownership of the extracted data buffer, so + // put it back into mData. + mData.replaceRawBuffer(elems, length); + } + // done.. cleanup + ReleaseData(); + mRequest = nullptr; + mObserver = nullptr; + } + return NS_OK; +} + +nsresult nsIncrementalStreamLoader::WriteSegmentFun( + nsIInputStream* inStr, void* closure, const char* fromSegment, + uint32_t toOffset, uint32_t count, uint32_t* writeCount) { + nsIncrementalStreamLoader* self = (nsIncrementalStreamLoader*)closure; + + const uint8_t* data = reinterpret_cast<const uint8_t*>(fromSegment); + uint32_t consumedCount = 0; + nsresult rv; + if (self->mData.empty()) { + // Shortcut when observer wants to keep the listener's buffer empty. + rv = self->mObserver->OnIncrementalData(self, self->mContext, count, data, + &consumedCount); + + if (rv != NS_OK) { + return rv; + } + + if (consumedCount > count) { + return NS_ERROR_INVALID_ARG; + } + + if (consumedCount < count) { + if (!self->mData.append(fromSegment + consumedCount, + count - consumedCount)) { + self->mData.clearAndFree(); + return NS_ERROR_OUT_OF_MEMORY; + } + } + } else { + // We have some non-consumed data from previous OnIncrementalData call, + // appending new data and reporting combined data. + if (!self->mData.append(fromSegment, count)) { + self->mData.clearAndFree(); + return NS_ERROR_OUT_OF_MEMORY; + } + size_t length = self->mData.length(); + uint32_t reportCount = length > UINT32_MAX ? UINT32_MAX : (uint32_t)length; + uint8_t* elems = self->mData.extractOrCopyRawBuffer(); + + rv = self->mObserver->OnIncrementalData(self, self->mContext, reportCount, + elems, &consumedCount); + + // We still own elems, freeing its memory when exiting scope. + if (rv != NS_OK) { + free(elems); + return rv; + } + + if (consumedCount > reportCount) { + free(elems); + return NS_ERROR_INVALID_ARG; + } + + if (consumedCount == length) { + free(elems); // good case -- fully consumed data + } else { + // Adopting elems back (at least its portion). + self->mData.replaceRawBuffer(elems, length); + if (consumedCount > 0) { + self->mData.erase(self->mData.begin() + consumedCount); + } + } + } + + *writeCount = count; + return NS_OK; +} + +NS_IMETHODIMP +nsIncrementalStreamLoader::OnDataAvailable(nsIRequest* request, + nsIInputStream* inStr, + uint64_t sourceOffset, + uint32_t count) { + if (mObserver) { + // provide nsIIncrementalStreamLoader::request during call to + // OnStreamComplete + mRequest = request; + } + uint32_t countRead; + nsresult rv = inStr->ReadSegments(WriteSegmentFun, this, count, &countRead); + mRequest = nullptr; + NS_ENSURE_SUCCESS(rv, rv); + mBytesRead += countRead; + return rv; +} + +void nsIncrementalStreamLoader::ReleaseData() { mData.clearAndFree(); } + +NS_IMETHODIMP +nsIncrementalStreamLoader::CheckListenerChain() { return NS_OK; } diff --git a/netwerk/base/nsIncrementalStreamLoader.h b/netwerk/base/nsIncrementalStreamLoader.h new file mode 100644 index 0000000000..3b19765e53 --- /dev/null +++ b/netwerk/base/nsIncrementalStreamLoader.h @@ -0,0 +1,54 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef nsIncrementalStreamLoader_h__ +#define nsIncrementalStreamLoader_h__ + +#include "nsIThreadRetargetableStreamListener.h" +#include "nsIIncrementalStreamLoader.h" +#include "nsCOMPtr.h" +#include "mozilla/Attributes.h" +#include "mozilla/Vector.h" + +class nsIRequest; + +class nsIncrementalStreamLoader final + : public nsIIncrementalStreamLoader, + public nsIThreadRetargetableStreamListener { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIINCREMENTALSTREAMLOADER + NS_DECL_NSIREQUESTOBSERVER + NS_DECL_NSISTREAMLISTENER + NS_DECL_NSITHREADRETARGETABLESTREAMLISTENER + + nsIncrementalStreamLoader(); + + static nsresult Create(nsISupports* aOuter, REFNSIID aIID, void** aResult); + + protected: + ~nsIncrementalStreamLoader() = default; + + static nsresult WriteSegmentFun(nsIInputStream*, void*, const char*, uint32_t, + uint32_t, uint32_t*); + + // Utility method to free mData, if present, and update other state to + // reflect that no data has been allocated. + void ReleaseData(); + + nsCOMPtr<nsIIncrementalStreamLoaderObserver> mObserver; + nsCOMPtr<nsISupports> mContext; // the observer's context + nsCOMPtr<nsIRequest> mRequest; + + // Buffer to accumulate incoming data. We preallocate if contentSize is + // available. + mozilla::Vector<uint8_t, 0> mData; + + // Number of bytes read, which may not match the number of bytes in mData at + // all, as we incrementally remove from there. + mozilla::Atomic<uint32_t, mozilla::MemoryOrdering::Relaxed> mBytesRead; +}; + +#endif // nsIncrementalStreamLoader_h__ diff --git a/netwerk/base/nsInputStreamChannel.cpp b/netwerk/base/nsInputStreamChannel.cpp new file mode 100644 index 0000000000..53e003948b --- /dev/null +++ b/netwerk/base/nsInputStreamChannel.cpp @@ -0,0 +1,102 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "nsInputStreamChannel.h" + +//----------------------------------------------------------------------------- +// nsInputStreamChannel + +namespace mozilla { +namespace net { + +nsresult nsInputStreamChannel::OpenContentStream(bool async, + nsIInputStream** result, + nsIChannel** channel) { + NS_ENSURE_TRUE(mContentStream, NS_ERROR_NOT_INITIALIZED); + + // If content length is unknown, then we must guess. In this case, we assume + // the stream can tell us. If the stream is a pipe, then this will not work. + + if (mContentLength < 0) { + uint64_t avail; + nsresult rv = mContentStream->Available(&avail); + if (rv == NS_BASE_STREAM_CLOSED) { + // This just means there's nothing in the stream + avail = 0; + } else if (NS_FAILED(rv)) { + return rv; + } + mContentLength = avail; + } + + EnableSynthesizedProgressEvents(true); + + *result = do_AddRef(mContentStream).take(); + return NS_OK; +} + +//----------------------------------------------------------------------------- +// nsInputStreamChannel::nsISupports + +NS_IMPL_ISUPPORTS_INHERITED(nsInputStreamChannel, nsBaseChannel, + nsIInputStreamChannel) + +//----------------------------------------------------------------------------- +// nsInputStreamChannel::nsIInputStreamChannel + +NS_IMETHODIMP +nsInputStreamChannel::SetURI(nsIURI* uri) { + NS_ENSURE_TRUE(!URI(), NS_ERROR_ALREADY_INITIALIZED); + nsBaseChannel::SetURI(uri); + return NS_OK; +} + +NS_IMETHODIMP +nsInputStreamChannel::GetContentStream(nsIInputStream** stream) { + NS_IF_ADDREF(*stream = mContentStream); + return NS_OK; +} + +NS_IMETHODIMP +nsInputStreamChannel::SetContentStream(nsIInputStream* stream) { + NS_ENSURE_TRUE(!mContentStream, NS_ERROR_ALREADY_INITIALIZED); + mContentStream = stream; + return NS_OK; +} + +NS_IMETHODIMP +nsInputStreamChannel::GetSrcdocData(nsAString& aSrcdocData) { + aSrcdocData = mSrcdocData; + return NS_OK; +} + +NS_IMETHODIMP +nsInputStreamChannel::SetSrcdocData(const nsAString& aSrcdocData) { + mSrcdocData = aSrcdocData; + mIsSrcdocChannel = true; + return NS_OK; +} + +NS_IMETHODIMP +nsInputStreamChannel::GetIsSrcdocChannel(bool* aIsSrcdocChannel) { + *aIsSrcdocChannel = mIsSrcdocChannel; + return NS_OK; +} + +NS_IMETHODIMP +nsInputStreamChannel::GetBaseURI(nsIURI** aBaseURI) { + *aBaseURI = mBaseURI; + NS_IF_ADDREF(*aBaseURI); + return NS_OK; +} + +NS_IMETHODIMP +nsInputStreamChannel::SetBaseURI(nsIURI* aBaseURI) { + mBaseURI = aBaseURI; + return NS_OK; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/nsInputStreamChannel.h b/netwerk/base/nsInputStreamChannel.h new file mode 100644 index 0000000000..f00df9536f --- /dev/null +++ b/netwerk/base/nsInputStreamChannel.h @@ -0,0 +1,43 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef nsInputStreamChannel_h__ +#define nsInputStreamChannel_h__ + +#include "nsBaseChannel.h" +#include "nsIInputStreamChannel.h" + +//----------------------------------------------------------------------------- + +namespace mozilla { +namespace net { + +class nsInputStreamChannel : public nsBaseChannel, + public nsIInputStreamChannel { + public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_NSIINPUTSTREAMCHANNEL + + nsInputStreamChannel() : mIsSrcdocChannel(false) {} + + protected: + virtual ~nsInputStreamChannel() = default; + + virtual nsresult OpenContentStream(bool async, nsIInputStream** result, + nsIChannel** channel) override; + + virtual void OnChannelDone() override { mContentStream = nullptr; } + + private: + nsCOMPtr<nsIInputStream> mContentStream; + nsCOMPtr<nsIURI> mBaseURI; + nsString mSrcdocData; + bool mIsSrcdocChannel; +}; + +} // namespace net +} // namespace mozilla + +#endif // !nsInputStreamChannel_h__ diff --git a/netwerk/base/nsInputStreamPump.cpp b/netwerk/base/nsInputStreamPump.cpp new file mode 100644 index 0000000000..80b5daa1ba --- /dev/null +++ b/netwerk/base/nsInputStreamPump.cpp @@ -0,0 +1,739 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=4 sts=2 sw=2 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/. */ + +#include "nsIOService.h" +#include "nsInputStreamPump.h" +#include "nsIStreamTransportService.h" +#include "nsIThreadRetargetableStreamListener.h" +#include "nsThreadUtils.h" +#include "nsCOMPtr.h" +#include "mozilla/Logging.h" +#include "mozilla/NonBlockingAsyncInputStream.h" +#include "mozilla/SlicedInputStream.h" +#include "GeckoProfiler.h" +#include "nsIStreamListener.h" +#include "nsILoadGroup.h" +#include "nsNetCID.h" +#include "nsStreamUtils.h" +#include <algorithm> + +static NS_DEFINE_CID(kStreamTransportServiceCID, NS_STREAMTRANSPORTSERVICE_CID); + +// +// MOZ_LOG=nsStreamPump:5 +// +static mozilla::LazyLogModule gStreamPumpLog("nsStreamPump"); +#undef LOG +#define LOG(args) MOZ_LOG(gStreamPumpLog, mozilla::LogLevel::Debug, args) + +//----------------------------------------------------------------------------- +// nsInputStreamPump methods +//----------------------------------------------------------------------------- + +nsInputStreamPump::nsInputStreamPump() + : mState(STATE_IDLE), + mStreamOffset(0), + mStreamLength(0), + mSegSize(0), + mSegCount(0), + mStatus(NS_OK), + mSuspendCount(0), + mLoadFlags(LOAD_NORMAL), + mIsPending(false), + mProcessingCallbacks(false), + mWaitingForInputStreamReady(false), + mCloseWhenDone(false), + mRetargeting(false), + mAsyncStreamIsBuffered(false), + mOffMainThread(!NS_IsMainThread()), + mMutex("nsInputStreamPump") {} + +nsresult nsInputStreamPump::Create(nsInputStreamPump** result, + nsIInputStream* stream, uint32_t segsize, + uint32_t segcount, bool closeWhenDone, + nsIEventTarget* mainThreadTarget) { + nsresult rv = NS_ERROR_OUT_OF_MEMORY; + RefPtr<nsInputStreamPump> pump = new nsInputStreamPump(); + if (pump) { + rv = pump->Init(stream, segsize, segcount, closeWhenDone, mainThreadTarget); + if (NS_SUCCEEDED(rv)) { + pump.forget(result); + } + } + return rv; +} + +struct PeekData { + PeekData(nsInputStreamPump::PeekSegmentFun fun, void* closure) + : mFunc(fun), mClosure(closure) {} + + nsInputStreamPump::PeekSegmentFun mFunc; + void* mClosure; +}; + +static nsresult CallPeekFunc(nsIInputStream* aInStream, void* aClosure, + const char* aFromSegment, uint32_t aToOffset, + uint32_t aCount, uint32_t* aWriteCount) { + NS_ASSERTION(aToOffset == 0, "Called more than once?"); + NS_ASSERTION(aCount > 0, "Called without data?"); + + PeekData* data = static_cast<PeekData*>(aClosure); + data->mFunc(data->mClosure, reinterpret_cast<const uint8_t*>(aFromSegment), + aCount); + return NS_BINDING_ABORTED; +} + +nsresult nsInputStreamPump::PeekStream(PeekSegmentFun callback, void* closure) { + RecursiveMutexAutoLock lock(mMutex); + + MOZ_ASSERT(mAsyncStream, "PeekStream called without stream"); + + nsresult rv = CreateBufferedStreamIfNeeded(); + NS_ENSURE_SUCCESS(rv, rv); + + // See if the pipe is closed by checking the return of Available. + uint64_t dummy64; + rv = mAsyncStream->Available(&dummy64); + if (NS_FAILED(rv)) return rv; + uint32_t dummy = (uint32_t)std::min(dummy64, (uint64_t)UINT32_MAX); + + PeekData data(callback, closure); + return mAsyncStream->ReadSegments( + CallPeekFunc, &data, net::nsIOService::gDefaultSegmentSize, &dummy); +} + +nsresult nsInputStreamPump::EnsureWaiting() { + mMutex.AssertCurrentThreadIn(); + + // no need to worry about multiple threads... an input stream pump lives + // on only one thread at a time. + MOZ_ASSERT(mAsyncStream); + if (!mWaitingForInputStreamReady && !mProcessingCallbacks) { + // Ensure OnStateStop is called on the main thread only when this pump is + // created on main thread. + if (mState == STATE_STOP && !mOffMainThread) { + nsCOMPtr<nsIEventTarget> mainThread = + mLabeledMainThreadTarget ? mLabeledMainThreadTarget + : do_AddRef(GetMainThreadEventTarget()); + if (mTargetThread != mainThread) { + mTargetThread = mainThread; + } + } + MOZ_ASSERT(mTargetThread); + nsresult rv = mAsyncStream->AsyncWait(this, 0, 0, mTargetThread); + if (NS_FAILED(rv)) { + NS_ERROR("AsyncWait failed"); + return rv; + } + // Any retargeting during STATE_START or START_TRANSFER is complete + // after the call to AsyncWait; next callback wil be on mTargetThread. + mRetargeting = false; + mWaitingForInputStreamReady = true; + } + return NS_OK; +} + +//----------------------------------------------------------------------------- +// nsInputStreamPump::nsISupports +//----------------------------------------------------------------------------- + +// although this class can only be accessed from one thread at a time, we do +// allow its ownership to move from thread to thread, assuming the consumer +// understands the limitations of this. +NS_IMPL_ADDREF(nsInputStreamPump) +NS_IMPL_RELEASE(nsInputStreamPump) +NS_INTERFACE_MAP_BEGIN(nsInputStreamPump) + NS_INTERFACE_MAP_ENTRY(nsIRequest) + NS_INTERFACE_MAP_ENTRY(nsIThreadRetargetableRequest) + NS_INTERFACE_MAP_ENTRY(nsIInputStreamCallback) + NS_INTERFACE_MAP_ENTRY(nsIInputStreamPump) + NS_INTERFACE_MAP_ENTRY_CONCRETE(nsInputStreamPump) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIInputStreamPump) +NS_INTERFACE_MAP_END + +//----------------------------------------------------------------------------- +// nsInputStreamPump::nsIRequest +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +nsInputStreamPump::GetName(nsACString& result) { + RecursiveMutexAutoLock lock(mMutex); + + result.Truncate(); + return NS_OK; +} + +NS_IMETHODIMP +nsInputStreamPump::IsPending(bool* result) { + RecursiveMutexAutoLock lock(mMutex); + + *result = (mState != STATE_IDLE); + return NS_OK; +} + +NS_IMETHODIMP +nsInputStreamPump::GetStatus(nsresult* status) { + RecursiveMutexAutoLock lock(mMutex); + + *status = mStatus; + return NS_OK; +} + +NS_IMETHODIMP +nsInputStreamPump::Cancel(nsresult status) { +#if DEBUG + if (mOffMainThread) { + MOZ_ASSERT_IF(mTargetThread, mTargetThread->IsOnCurrentThread()); + } else { + MOZ_ASSERT(NS_IsMainThread()); + } +#endif + + RecursiveMutexAutoLock lock(mMutex); + + LOG(("nsInputStreamPump::Cancel [this=%p status=%" PRIx32 "]\n", this, + static_cast<uint32_t>(status))); + + if (NS_FAILED(mStatus)) { + LOG((" already canceled\n")); + return NS_OK; + } + + NS_ASSERTION(NS_FAILED(status), "cancel with non-failure status code"); + mStatus = status; + + // close input stream + if (mAsyncStream) { + mAsyncStream->CloseWithStatus(status); + if (mSuspendCount == 0) EnsureWaiting(); + // Otherwise, EnsureWaiting will be called by Resume(). + // Note that while suspended, OnInputStreamReady will + // not do anything, and also note that calling asyncWait + // on a closed stream works and will dispatch an event immediately. + } + return NS_OK; +} + +NS_IMETHODIMP +nsInputStreamPump::Suspend() { + RecursiveMutexAutoLock lock(mMutex); + + LOG(("nsInputStreamPump::Suspend [this=%p]\n", this)); + NS_ENSURE_TRUE(mState != STATE_IDLE, NS_ERROR_UNEXPECTED); + ++mSuspendCount; + return NS_OK; +} + +NS_IMETHODIMP +nsInputStreamPump::Resume() { + RecursiveMutexAutoLock lock(mMutex); + + LOG(("nsInputStreamPump::Resume [this=%p]\n", this)); + NS_ENSURE_TRUE(mSuspendCount > 0, NS_ERROR_UNEXPECTED); + NS_ENSURE_TRUE(mState != STATE_IDLE, NS_ERROR_UNEXPECTED); + + // There is a brief in-between state when we null out mAsyncStream in + // OnStateStop() before calling OnStopRequest, and only afterwards set + // STATE_IDLE, which we need to handle gracefully. + if (--mSuspendCount == 0 && mAsyncStream) EnsureWaiting(); + return NS_OK; +} + +NS_IMETHODIMP +nsInputStreamPump::GetLoadFlags(nsLoadFlags* aLoadFlags) { + RecursiveMutexAutoLock lock(mMutex); + + *aLoadFlags = mLoadFlags; + return NS_OK; +} + +NS_IMETHODIMP +nsInputStreamPump::SetLoadFlags(nsLoadFlags aLoadFlags) { + RecursiveMutexAutoLock lock(mMutex); + + mLoadFlags = aLoadFlags; + return NS_OK; +} + +NS_IMETHODIMP +nsInputStreamPump::GetTRRMode(nsIRequest::TRRMode* aTRRMode) { + return GetTRRModeImpl(aTRRMode); +} + +NS_IMETHODIMP +nsInputStreamPump::SetTRRMode(nsIRequest::TRRMode aTRRMode) { + return SetTRRModeImpl(aTRRMode); +} + +NS_IMETHODIMP +nsInputStreamPump::GetLoadGroup(nsILoadGroup** aLoadGroup) { + RecursiveMutexAutoLock lock(mMutex); + + NS_IF_ADDREF(*aLoadGroup = mLoadGroup); + return NS_OK; +} + +NS_IMETHODIMP +nsInputStreamPump::SetLoadGroup(nsILoadGroup* aLoadGroup) { + RecursiveMutexAutoLock lock(mMutex); + + mLoadGroup = aLoadGroup; + return NS_OK; +} + +//----------------------------------------------------------------------------- +// nsInputStreamPump::nsIInputStreamPump implementation +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +nsInputStreamPump::Init(nsIInputStream* stream, uint32_t segsize, + uint32_t segcount, bool closeWhenDone, + nsIEventTarget* mainThreadTarget) { + NS_ENSURE_TRUE(mState == STATE_IDLE, NS_ERROR_IN_PROGRESS); + + mStream = stream; + mSegSize = segsize; + mSegCount = segcount; + mCloseWhenDone = closeWhenDone; + mLabeledMainThreadTarget = mainThreadTarget; + if (mOffMainThread && mLabeledMainThreadTarget) { + MOZ_ASSERT( + false, + "Init stream pump off main thread with a main thread event target."); + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +NS_IMETHODIMP +nsInputStreamPump::AsyncRead(nsIStreamListener* listener) { + RecursiveMutexAutoLock lock(mMutex); + + NS_ENSURE_TRUE(mState == STATE_IDLE, NS_ERROR_IN_PROGRESS); + NS_ENSURE_ARG_POINTER(listener); + MOZ_ASSERT(NS_IsMainThread() || mOffMainThread, + "nsInputStreamPump should be read from the " + "main thread only."); + + nsresult rv = NS_MakeAsyncNonBlockingInputStream( + mStream.forget(), getter_AddRefs(mAsyncStream), mCloseWhenDone, mSegSize, + mSegCount); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + MOZ_ASSERT(mAsyncStream); + + // mStreamOffset now holds the number of bytes currently read. + mStreamOffset = 0; + + // grab event queue (we must do this here by contract, since all notifications + // must go to the thread which called AsyncRead) + if (NS_IsMainThread() && mLabeledMainThreadTarget) { + mTargetThread = mLabeledMainThreadTarget; + } else { + mTargetThread = GetCurrentEventTarget(); + } + NS_ENSURE_STATE(mTargetThread); + + rv = EnsureWaiting(); + if (NS_FAILED(rv)) return rv; + + if (mLoadGroup) mLoadGroup->AddRequest(this, nullptr); + + mState = STATE_START; + mListener = listener; + return NS_OK; +} + +//----------------------------------------------------------------------------- +// nsInputStreamPump::nsIInputStreamCallback implementation +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +nsInputStreamPump::OnInputStreamReady(nsIAsyncInputStream* stream) { + LOG(("nsInputStreamPump::OnInputStreamReady [this=%p]\n", this)); + + AUTO_PROFILER_LABEL("nsInputStreamPump::OnInputStreamReady", NETWORK); + + // this function has been called from a PLEvent, so we can safely call + // any listener or progress sink methods directly from here. + + for (;;) { + // There should only be one iteration of this loop happening at a time. + // To prevent AsyncWait() (called during callbacks or on other threads) + // from creating a parallel OnInputStreamReady(), we use: + // -- a mutex; and + // -- a boolean mProcessingCallbacks to detect parallel loops + // when exiting the mutex for callbacks. + RecursiveMutexAutoLock lock(mMutex); + + // Prevent parallel execution during callbacks, while out of mutex. + if (mProcessingCallbacks) { + MOZ_ASSERT(!mProcessingCallbacks); + break; + } + mProcessingCallbacks = true; + if (mSuspendCount || mState == STATE_IDLE) { + mWaitingForInputStreamReady = false; + mProcessingCallbacks = false; + break; + } + + uint32_t nextState; + switch (mState) { + case STATE_START: + nextState = OnStateStart(); + break; + case STATE_TRANSFER: + nextState = OnStateTransfer(); + break; + case STATE_STOP: + mRetargeting = false; + nextState = OnStateStop(); + break; + default: + nextState = 0; + MOZ_ASSERT_UNREACHABLE("Unknown enum value."); + return NS_ERROR_UNEXPECTED; + } + + bool stillTransferring = + (mState == STATE_TRANSFER && nextState == STATE_TRANSFER); + if (stillTransferring) { + NS_ASSERTION(NS_SUCCEEDED(mStatus), + "Should not have failed status for ongoing transfer"); + } else { + NS_ASSERTION(mState != nextState, + "Only OnStateTransfer can be called more than once."); + } + if (mRetargeting) { + NS_ASSERTION(mState != STATE_STOP, + "Retargeting should not happen during OnStateStop."); + } + + // Set mRetargeting so EnsureWaiting will be called. It ensures that + // OnStateStop is called on the main thread. + if (nextState == STATE_STOP && !NS_IsMainThread() && !mOffMainThread) { + mRetargeting = true; + } + + // Unset mProcessingCallbacks here (while we have lock) so our own call to + // EnsureWaiting isn't blocked by it. + mProcessingCallbacks = false; + + // We must break the loop if suspended during one of the previous + // operation. + if (mSuspendCount) { + mState = nextState; + mWaitingForInputStreamReady = false; + break; + } + + // Wait asynchronously if there is still data to transfer, or we're + // switching event delivery to another thread. + if (stillTransferring || mRetargeting) { + mState = nextState; + mWaitingForInputStreamReady = false; + nsresult rv = EnsureWaiting(); + if (NS_SUCCEEDED(rv)) break; + + // Failure to start asynchronous wait: stop transfer. + // Do not set mStatus if it was previously set to report a failure. + if (NS_SUCCEEDED(mStatus)) { + mStatus = rv; + } + nextState = STATE_STOP; + } + + mState = nextState; + } + return NS_OK; +} + +uint32_t nsInputStreamPump::OnStateStart() { + mMutex.AssertCurrentThreadIn(); + + AUTO_PROFILER_LABEL("nsInputStreamPump::OnStateStart", NETWORK); + + LOG((" OnStateStart [this=%p]\n", this)); + + nsresult rv; + + // need to check the reason why the stream is ready. this is required + // so our listener can check our status from OnStartRequest. + // XXX async streams should have a GetStatus method! + if (NS_SUCCEEDED(mStatus)) { + uint64_t avail; + rv = mAsyncStream->Available(&avail); + if (NS_FAILED(rv) && rv != NS_BASE_STREAM_CLOSED) mStatus = rv; + } + + { + // Note: Must exit mutex for call to OnStartRequest to avoid + // deadlocks when calls to RetargetDeliveryTo for multiple + // nsInputStreamPumps are needed (e.g. nsHttpChannel). + RecursiveMutexAutoUnlock unlock(mMutex); + rv = mListener->OnStartRequest(this); + } + + // an error returned from OnStartRequest should cause us to abort; however, + // we must not stomp on mStatus if already canceled. + if (NS_FAILED(rv) && NS_SUCCEEDED(mStatus)) mStatus = rv; + + return NS_SUCCEEDED(mStatus) ? STATE_TRANSFER : STATE_STOP; +} + +uint32_t nsInputStreamPump::OnStateTransfer() { + mMutex.AssertCurrentThreadIn(); + + AUTO_PROFILER_LABEL("nsInputStreamPump::OnStateTransfer", NETWORK); + + LOG((" OnStateTransfer [this=%p]\n", this)); + + // if canceled, go directly to STATE_STOP... + if (NS_FAILED(mStatus)) return STATE_STOP; + + nsresult rv = CreateBufferedStreamIfNeeded(); + if (NS_WARN_IF(NS_FAILED(rv))) { + return STATE_STOP; + } + + uint64_t avail; + rv = mAsyncStream->Available(&avail); + LOG((" Available returned [stream=%p rv=%" PRIx32 " avail=%" PRIu64 "]\n", + mAsyncStream.get(), static_cast<uint32_t>(rv), avail)); + + if (rv == NS_BASE_STREAM_CLOSED) { + rv = NS_OK; + avail = 0; + } else if (NS_SUCCEEDED(rv) && avail) { + // we used to limit avail to 16K - we were afraid some ODA handlers + // might assume they wouldn't get more than 16K at once + // we're removing that limit since it speeds up local file access. + // Now there's an implicit 64K limit of 4 16K segments + // NOTE: ok, so the story is as follows. OnDataAvailable impls + // are by contract supposed to consume exactly |avail| bytes. + // however, many do not... mailnews... stream converters... + // cough, cough. the input stream pump is fairly tolerant + // in this regard; however, if an ODA does not consume any + // data from the stream, then we could potentially end up in + // an infinite loop. we do our best here to try to catch + // such an error. (see bug 189672) + + // in most cases this QI will succeed (mAsyncStream is almost always + // a nsPipeInputStream, which implements nsITellableStream::Tell). + int64_t offsetBefore; + nsCOMPtr<nsITellableStream> tellable = do_QueryInterface(mAsyncStream); + if (tellable && NS_FAILED(tellable->Tell(&offsetBefore))) { + MOZ_ASSERT_UNREACHABLE("Tell failed on readable stream"); + offsetBefore = 0; + } + + uint32_t odaAvail = avail > UINT32_MAX ? UINT32_MAX : uint32_t(avail); + + LOG((" calling OnDataAvailable [offset=%" PRIu64 " count=%" PRIu64 + "(%u)]\n", + mStreamOffset, avail, odaAvail)); + + { + // Note: Must exit mutex for call to OnStartRequest to avoid + // deadlocks when calls to RetargetDeliveryTo for multiple + // nsInputStreamPumps are needed (e.g. nsHttpChannel). + RecursiveMutexAutoUnlock unlock(mMutex); + rv = mListener->OnDataAvailable(this, mAsyncStream, mStreamOffset, + odaAvail); + } + + // don't enter this code if ODA failed or called Cancel + if (NS_SUCCEEDED(rv) && NS_SUCCEEDED(mStatus)) { + // test to see if this ODA failed to consume data + if (tellable) { + // NOTE: if Tell fails, which can happen if the stream is + // now closed, then we assume that everything was read. + int64_t offsetAfter; + if (NS_FAILED(tellable->Tell(&offsetAfter))) + offsetAfter = offsetBefore + odaAvail; + if (offsetAfter > offsetBefore) + mStreamOffset += (offsetAfter - offsetBefore); + else if (mSuspendCount == 0) { + // + // possible infinite loop if we continue pumping data! + // + // NOTE: although not allowed by nsIStreamListener, we + // will allow the ODA impl to Suspend the pump. IMAP + // does this :-( + // + NS_ERROR("OnDataAvailable implementation consumed no data"); + mStatus = NS_ERROR_UNEXPECTED; + } + } else + mStreamOffset += odaAvail; // assume ODA behaved well + } + } + + // an error returned from Available or OnDataAvailable should cause us to + // abort; however, we must not stop on mStatus if already canceled. + + if (NS_SUCCEEDED(mStatus)) { + if (NS_FAILED(rv)) + mStatus = rv; + else if (avail) { + // if stream is now closed, advance to STATE_STOP right away. + // Available may return 0 bytes available at the moment; that + // would not mean that we are done. + // XXX async streams should have a GetStatus method! + rv = mAsyncStream->Available(&avail); + if (NS_SUCCEEDED(rv)) return STATE_TRANSFER; + if (rv != NS_BASE_STREAM_CLOSED) mStatus = rv; + } + } + return STATE_STOP; +} + +nsresult nsInputStreamPump::CallOnStateStop() { + RecursiveMutexAutoLock lock(mMutex); + + MOZ_ASSERT(NS_IsMainThread(), + "CallOnStateStop should only be called on the main thread."); + + mState = OnStateStop(); + return NS_OK; +} + +uint32_t nsInputStreamPump::OnStateStop() { + mMutex.AssertCurrentThreadIn(); + + if (!NS_IsMainThread() && !mOffMainThread) { + // This method can be called on a different thread if nsInputStreamPump + // is used off the main-thread. + nsresult rv = mLabeledMainThreadTarget->Dispatch( + NewRunnableMethod("nsInputStreamPump::CallOnStateStop", this, + &nsInputStreamPump::CallOnStateStop)); + NS_ENSURE_SUCCESS(rv, STATE_IDLE); + return STATE_IDLE; + } + + AUTO_PROFILER_LABEL("nsInputStreamPump::OnStateStop", NETWORK); + + LOG((" OnStateStop [this=%p status=%" PRIx32 "]\n", this, + static_cast<uint32_t>(mStatus))); + + // if an error occurred, we must be sure to pass the error onto the async + // stream. in some cases, this is redundant, but since close is idempotent, + // this is OK. otherwise, be sure to honor the "close-when-done" option. + + if (!mAsyncStream || !mListener) { + MOZ_ASSERT(mAsyncStream, "null mAsyncStream: OnStateStop called twice?"); + MOZ_ASSERT(mListener, "null mListener: OnStateStop called twice?"); + return STATE_IDLE; + } + + if (NS_FAILED(mStatus)) + mAsyncStream->CloseWithStatus(mStatus); + else if (mCloseWhenDone) + mAsyncStream->Close(); + + mAsyncStream = nullptr; + mTargetThread = nullptr; + mIsPending = false; + { + // Note: Must exit mutex for call to OnStartRequest to avoid + // deadlocks when calls to RetargetDeliveryTo for multiple + // nsInputStreamPumps are needed (e.g. nsHttpChannel). + RecursiveMutexAutoUnlock unlock(mMutex); + mListener->OnStopRequest(this, mStatus); + } + mListener = nullptr; + + if (mLoadGroup) mLoadGroup->RemoveRequest(this, nullptr, mStatus); + + return STATE_IDLE; +} + +nsresult nsInputStreamPump::CreateBufferedStreamIfNeeded() { + if (mAsyncStreamIsBuffered) { + return NS_OK; + } + + // ReadSegments is not available for any nsIAsyncInputStream. In order to use + // it, we wrap a nsIBufferedInputStream around it, if needed. + + if (NS_InputStreamIsBuffered(mAsyncStream)) { + mAsyncStreamIsBuffered = true; + return NS_OK; + } + + nsCOMPtr<nsIInputStream> stream; + nsresult rv = NS_NewBufferedInputStream(getter_AddRefs(stream), + mAsyncStream.forget(), 4096); + NS_ENSURE_SUCCESS(rv, rv); + + // A buffered inputStream must implement nsIAsyncInputStream. + mAsyncStream = do_QueryInterface(stream); + MOZ_DIAGNOSTIC_ASSERT(mAsyncStream); + mAsyncStreamIsBuffered = true; + + return NS_OK; +} + +//----------------------------------------------------------------------------- +// nsIThreadRetargetableRequest +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +nsInputStreamPump::RetargetDeliveryTo(nsIEventTarget* aNewTarget) { + RecursiveMutexAutoLock lock(mMutex); + + NS_ENSURE_ARG(aNewTarget); + NS_ENSURE_TRUE(mState == STATE_START || mState == STATE_TRANSFER, + NS_ERROR_UNEXPECTED); + + // If canceled, do not retarget. Return with canceled status. + if (NS_FAILED(mStatus)) { + return mStatus; + } + + if (aNewTarget == mTargetThread) { + NS_WARNING("Retargeting delivery to same thread"); + return NS_OK; + } + + if (mOffMainThread) { + // Don't support retargeting if this pump is already used off the main + // thread. + return NS_ERROR_FAILURE; + } + + // Ensure that |mListener| and any subsequent listeners can be retargeted + // to another thread. + nsresult rv = NS_OK; + nsCOMPtr<nsIThreadRetargetableStreamListener> retargetableListener = + do_QueryInterface(mListener, &rv); + if (NS_SUCCEEDED(rv) && retargetableListener) { + rv = retargetableListener->CheckListenerChain(); + if (NS_SUCCEEDED(rv)) { + mTargetThread = aNewTarget; + mRetargeting = true; + } + } + LOG( + ("nsInputStreamPump::RetargetDeliveryTo [this=%p aNewTarget=%p] " + "%s listener [%p] rv[%" PRIx32 "]", + this, aNewTarget, (mTargetThread == aNewTarget ? "success" : "failure"), + (nsIStreamListener*)mListener, static_cast<uint32_t>(rv))); + return rv; +} + +NS_IMETHODIMP +nsInputStreamPump::GetDeliveryTarget(nsIEventTarget** aNewTarget) { + RecursiveMutexAutoLock lock(mMutex); + + nsCOMPtr<nsIEventTarget> target = mTargetThread; + target.forget(aNewTarget); + return NS_OK; +} diff --git a/netwerk/base/nsInputStreamPump.h b/netwerk/base/nsInputStreamPump.h new file mode 100644 index 0000000000..a9f8525088 --- /dev/null +++ b/netwerk/base/nsInputStreamPump.h @@ -0,0 +1,110 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef nsInputStreamPump_h__ +#define nsInputStreamPump_h__ + +#include "nsIInputStreamPump.h" +#include "nsIAsyncInputStream.h" +#include "nsIThreadRetargetableRequest.h" +#include "nsCOMPtr.h" +#include "mozilla/Attributes.h" +#include "mozilla/RecursiveMutex.h" + +class nsIInputStream; +class nsILoadGroup; +class nsIStreamListener; + +#define NS_INPUT_STREAM_PUMP_IID \ + { \ + 0x42f1cc9b, 0xdf5f, 0x4c9b, { \ + 0xbd, 0x71, 0x8d, 0x4a, 0xe2, 0x27, 0xc1, 0x8a \ + } \ + } + +class nsInputStreamPump final : public nsIInputStreamPump, + public nsIInputStreamCallback, + public nsIThreadRetargetableRequest { + ~nsInputStreamPump() = default; + + public: + typedef mozilla::RecursiveMutexAutoLock RecursiveMutexAutoLock; + typedef mozilla::RecursiveMutexAutoUnlock RecursiveMutexAutoUnlock; + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIREQUEST + NS_DECL_NSIINPUTSTREAMPUMP + NS_DECL_NSIINPUTSTREAMCALLBACK + NS_DECL_NSITHREADRETARGETABLEREQUEST + NS_DECLARE_STATIC_IID_ACCESSOR(NS_INPUT_STREAM_PUMP_IID) + + nsInputStreamPump(); + + static nsresult Create(nsInputStreamPump** result, nsIInputStream* stream, + uint32_t segsize = 0, uint32_t segcount = 0, + bool closeWhenDone = false, + nsIEventTarget* mainThreadTarget = nullptr); + + typedef void (*PeekSegmentFun)(void* closure, const uint8_t* buf, + uint32_t bufLen); + /** + * Peek into the first chunk of data that's in the stream. Note that this + * method will not call the callback when there is no data in the stream. + * The callback will be called at most once. + * + * The data from the stream will not be consumed, i.e. the pump's listener + * can still read all the data. + * + * Do not call before asyncRead. Do not call after onStopRequest. + */ + nsresult PeekStream(PeekSegmentFun callback, void* closure); + + /** + * Dispatched (to the main thread) by OnStateStop if it's called off main + * thread. Updates mState based on return value of OnStateStop. + */ + nsresult CallOnStateStop(); + + protected: + enum { STATE_IDLE, STATE_START, STATE_TRANSFER, STATE_STOP }; + + nsresult EnsureWaiting(); + uint32_t OnStateStart(); + uint32_t OnStateTransfer(); + uint32_t OnStateStop(); + nsresult CreateBufferedStreamIfNeeded(); + + uint32_t mState; + nsCOMPtr<nsILoadGroup> mLoadGroup; + nsCOMPtr<nsIStreamListener> mListener; + nsCOMPtr<nsIEventTarget> mTargetThread; + nsCOMPtr<nsIEventTarget> mLabeledMainThreadTarget; + nsCOMPtr<nsIInputStream> mStream; + nsCOMPtr<nsIAsyncInputStream> mAsyncStream; + uint64_t mStreamOffset; + uint64_t mStreamLength; + uint32_t mSegSize; + uint32_t mSegCount; + nsresult mStatus; + uint32_t mSuspendCount; + uint32_t mLoadFlags; + bool mIsPending; + // True while in OnInputStreamReady, calling OnStateStart, OnStateTransfer + // and OnStateStop. Used to prevent calls to AsyncWait during callbacks. + bool mProcessingCallbacks; + // True if waiting on the "input stream ready" callback. + bool mWaitingForInputStreamReady; + bool mCloseWhenDone; + bool mRetargeting; + bool mAsyncStreamIsBuffered; + // Indicate whether nsInputStreamPump is used completely off main thread. + // If true, OnStateStop() is executed off main thread. + bool mOffMainThread; + // Protects state/member var accesses across multiple threads. + mozilla::RecursiveMutex mMutex; +}; + +NS_DEFINE_STATIC_IID_ACCESSOR(nsInputStreamPump, NS_INPUT_STREAM_PUMP_IID) + +#endif // !nsInputStreamChannel_h__ diff --git a/netwerk/base/nsLoadGroup.cpp b/netwerk/base/nsLoadGroup.cpp new file mode 100644 index 0000000000..ea8acb73cb --- /dev/null +++ b/netwerk/base/nsLoadGroup.cpp @@ -0,0 +1,1079 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set sw=2 ts=4 sts=2 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/. */ + +#include "mozilla/DebugOnly.h" + +#include "nsLoadGroup.h" + +#include "nsArrayEnumerator.h" +#include "nsCOMArray.h" +#include "nsCOMPtr.h" +#include "nsContentUtils.h" +#include "mozilla/Logging.h" +#include "nsString.h" +#include "nsTArray.h" +#include "mozilla/Telemetry.h" +#include "nsIHttpChannelInternal.h" +#include "nsITimedChannel.h" +#include "nsIInterfaceRequestor.h" +#include "nsIRequestObserver.h" +#include "CacheObserver.h" +#include "MainThreadUtils.h" +#include "RequestContextService.h" +#include "mozilla/StoragePrincipalHelper.h" +#include "mozilla/Unused.h" + +namespace mozilla { +namespace net { + +// +// Log module for nsILoadGroup logging... +// +// To enable logging (see prlog.h for full details): +// +// set MOZ_LOG=LoadGroup:5 +// set MOZ_LOG_FILE=network.log +// +// This enables LogLevel::Debug level information and places all output in +// the file network.log. +// +static LazyLogModule gLoadGroupLog("LoadGroup"); +#undef LOG +#define LOG(args) MOZ_LOG(gLoadGroupLog, mozilla::LogLevel::Debug, args) + +//////////////////////////////////////////////////////////////////////////////// + +class RequestMapEntry : public PLDHashEntryHdr { + public: + explicit RequestMapEntry(nsIRequest* aRequest) : mKey(aRequest) {} + + nsCOMPtr<nsIRequest> mKey; +}; + +static bool RequestHashMatchEntry(const PLDHashEntryHdr* entry, + const void* key) { + const RequestMapEntry* e = static_cast<const RequestMapEntry*>(entry); + const nsIRequest* request = static_cast<const nsIRequest*>(key); + + return e->mKey == request; +} + +static void RequestHashClearEntry(PLDHashTable* table, PLDHashEntryHdr* entry) { + RequestMapEntry* e = static_cast<RequestMapEntry*>(entry); + + // An entry is being cleared, let the entry do its own cleanup. + e->~RequestMapEntry(); +} + +static void RequestHashInitEntry(PLDHashEntryHdr* entry, const void* key) { + const nsIRequest* const_request = static_cast<const nsIRequest*>(key); + nsIRequest* request = const_cast<nsIRequest*>(const_request); + + // Initialize the entry with placement new + new (entry) RequestMapEntry(request); +} + +static const PLDHashTableOps sRequestHashOps = { + PLDHashTable::HashVoidPtrKeyStub, RequestHashMatchEntry, + PLDHashTable::MoveEntryStub, RequestHashClearEntry, RequestHashInitEntry}; + +static void RescheduleRequest(nsIRequest* aRequest, int32_t delta) { + nsCOMPtr<nsISupportsPriority> p = do_QueryInterface(aRequest); + if (p) p->AdjustPriority(delta); +} + +nsLoadGroup::nsLoadGroup() + : mForegroundCount(0), + mLoadFlags(LOAD_NORMAL), + mDefaultLoadFlags(0), + mPriority(PRIORITY_NORMAL), + mRequests(&sRequestHashOps, sizeof(RequestMapEntry)), + mStatus(NS_OK), + mIsCanceling(false), + mDefaultLoadIsTimed(false), + mBrowsingContextDiscarded(false), + mExternalRequestContext(false), + mTimedRequests(0), + mCachedRequests(0) { + LOG(("LOADGROUP [%p]: Created.\n", this)); +} + +nsLoadGroup::~nsLoadGroup() { + DebugOnly<nsresult> rv = Cancel(NS_BINDING_ABORTED); + NS_ASSERTION(NS_SUCCEEDED(rv), "Cancel failed"); + + mDefaultLoadRequest = nullptr; + + if (mRequestContext && !mExternalRequestContext) { + mRequestContextService->RemoveRequestContext(mRequestContext->GetID()); + if (IsNeckoChild() && gNeckoChild) { + gNeckoChild->SendRemoveRequestContext(mRequestContext->GetID()); + } + } + + nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService(); + if (os) { + Unused << os->RemoveObserver(this, "last-pb-context-exited"); + } + + LOG(("LOADGROUP [%p]: Destroyed.\n", this)); +} + +//////////////////////////////////////////////////////////////////////////////// +// nsISupports methods: + +NS_IMPL_ISUPPORTS(nsLoadGroup, nsILoadGroup, nsILoadGroupChild, nsIRequest, + nsISupportsPriority, nsISupportsWeakReference, nsIObserver) + +//////////////////////////////////////////////////////////////////////////////// +// nsIRequest methods: + +NS_IMETHODIMP +nsLoadGroup::GetName(nsACString& result) { + // XXX is this the right "name" for a load group? + + if (!mDefaultLoadRequest) { + result.Truncate(); + return NS_OK; + } + + return mDefaultLoadRequest->GetName(result); +} + +NS_IMETHODIMP +nsLoadGroup::IsPending(bool* aResult) { + *aResult = (mForegroundCount > 0) ? true : false; + return NS_OK; +} + +NS_IMETHODIMP +nsLoadGroup::GetStatus(nsresult* status) { + if (NS_SUCCEEDED(mStatus) && mDefaultLoadRequest) + return mDefaultLoadRequest->GetStatus(status); + + *status = mStatus; + return NS_OK; +} + +static bool AppendRequestsToArray(PLDHashTable* aTable, + nsTArray<nsIRequest*>* aArray) { + for (auto iter = aTable->Iter(); !iter.Done(); iter.Next()) { + auto e = static_cast<RequestMapEntry*>(iter.Get()); + nsIRequest* request = e->mKey; + NS_ASSERTION(request, "What? Null key in PLDHashTable entry?"); + + // XXX(Bug 1631371) Check if this should use a fallible operation as it + // pretended earlier. + aArray->AppendElement(request); + NS_ADDREF(request); + } + + if (aArray->Length() != aTable->EntryCount()) { + for (uint32_t i = 0, len = aArray->Length(); i < len; ++i) { + NS_RELEASE((*aArray)[i]); + } + return false; + } + return true; +} + +NS_IMETHODIMP +nsLoadGroup::Cancel(nsresult status) { + MOZ_ASSERT(NS_IsMainThread()); + + NS_ASSERTION(NS_FAILED(status), "shouldn't cancel with a success code"); + nsresult rv; + uint32_t count = mRequests.EntryCount(); + + AutoTArray<nsIRequest*, 8> requests; + + if (!AppendRequestsToArray(&mRequests, &requests)) { + return NS_ERROR_OUT_OF_MEMORY; + } + + // set the load group status to our cancel status while we cancel + // all our requests...once the cancel is done, we'll reset it... + // + mStatus = status; + + // Set the flag indicating that the loadgroup is being canceled... This + // prevents any new channels from being added during the operation. + // + mIsCanceling = true; + + nsresult firstError = NS_OK; + while (count > 0) { + nsCOMPtr<nsIRequest> request = requests.ElementAt(--count); + + NS_ASSERTION(request, "NULL request found in list."); + + if (!mRequests.Search(request)) { + // |request| was removed already + // We need to null out the entry in the request array so we don't try + // to notify the observers for this request. + nsCOMPtr<nsIRequest> request = dont_AddRef(requests.ElementAt(count)); + requests.ElementAt(count) = nullptr; + + continue; + } + + if (MOZ_LOG_TEST(gLoadGroupLog, LogLevel::Debug)) { + nsAutoCString nameStr; + request->GetName(nameStr); + LOG(("LOADGROUP [%p]: Canceling request %p %s.\n", this, request.get(), + nameStr.get())); + } + + // Cancel the request... + rv = request->Cancel(status); + + // Remember the first failure and return it... + if (NS_FAILED(rv) && NS_SUCCEEDED(firstError)) firstError = rv; + + if (NS_FAILED(RemoveRequestFromHashtable(request, status))) { + // It's possible that request->Cancel causes the request to be removed + // from the loadgroup causing RemoveRequestFromHashtable to fail. + // In that case we shouldn't call NotifyRemovalObservers or decrement + // mForegroundCount since that has already happened. + nsCOMPtr<nsIRequest> request = dont_AddRef(requests.ElementAt(count)); + requests.ElementAt(count) = nullptr; + + continue; + } + } + + for (count = requests.Length(); count > 0;) { + nsCOMPtr<nsIRequest> request = dont_AddRef(requests.ElementAt(--count)); + (void)NotifyRemovalObservers(request, status); + } + + if (mRequestContext) { + Unused << mRequestContext->CancelTailPendingRequests(status); + } + +#if defined(DEBUG) + NS_ASSERTION(mRequests.EntryCount() == 0, "Request list is not empty."); + NS_ASSERTION(mForegroundCount == 0, "Foreground URLs are active."); +#endif + + mStatus = NS_OK; + mIsCanceling = false; + + return firstError; +} + +NS_IMETHODIMP +nsLoadGroup::Suspend() { + nsresult rv, firstError; + uint32_t count = mRequests.EntryCount(); + + AutoTArray<nsIRequest*, 8> requests; + + if (!AppendRequestsToArray(&mRequests, &requests)) { + return NS_ERROR_OUT_OF_MEMORY; + } + + firstError = NS_OK; + // + // Operate the elements from back to front so that if items get + // get removed from the list it won't affect our iteration + // + while (count > 0) { + nsCOMPtr<nsIRequest> request = dont_AddRef(requests.ElementAt(--count)); + + NS_ASSERTION(request, "NULL request found in list."); + if (!request) continue; + + if (MOZ_LOG_TEST(gLoadGroupLog, LogLevel::Debug)) { + nsAutoCString nameStr; + request->GetName(nameStr); + LOG(("LOADGROUP [%p]: Suspending request %p %s.\n", this, request.get(), + nameStr.get())); + } + + // Suspend the request... + rv = request->Suspend(); + + // Remember the first failure and return it... + if (NS_FAILED(rv) && NS_SUCCEEDED(firstError)) firstError = rv; + } + + return firstError; +} + +NS_IMETHODIMP +nsLoadGroup::Resume() { + nsresult rv, firstError; + uint32_t count = mRequests.EntryCount(); + + AutoTArray<nsIRequest*, 8> requests; + + if (!AppendRequestsToArray(&mRequests, &requests)) { + return NS_ERROR_OUT_OF_MEMORY; + } + + firstError = NS_OK; + // + // Operate the elements from back to front so that if items get + // get removed from the list it won't affect our iteration + // + while (count > 0) { + nsCOMPtr<nsIRequest> request = dont_AddRef(requests.ElementAt(--count)); + + NS_ASSERTION(request, "NULL request found in list."); + if (!request) continue; + + if (MOZ_LOG_TEST(gLoadGroupLog, LogLevel::Debug)) { + nsAutoCString nameStr; + request->GetName(nameStr); + LOG(("LOADGROUP [%p]: Resuming request %p %s.\n", this, request.get(), + nameStr.get())); + } + + // Resume the request... + rv = request->Resume(); + + // Remember the first failure and return it... + if (NS_FAILED(rv) && NS_SUCCEEDED(firstError)) firstError = rv; + } + + return firstError; +} + +NS_IMETHODIMP +nsLoadGroup::GetLoadFlags(uint32_t* aLoadFlags) { + *aLoadFlags = mLoadFlags; + return NS_OK; +} + +NS_IMETHODIMP +nsLoadGroup::SetLoadFlags(uint32_t aLoadFlags) { + mLoadFlags = aLoadFlags; + return NS_OK; +} + +NS_IMETHODIMP +nsLoadGroup::GetTRRMode(nsIRequest::TRRMode* aTRRMode) { + return GetTRRModeImpl(aTRRMode); +} + +NS_IMETHODIMP +nsLoadGroup::SetTRRMode(nsIRequest::TRRMode aTRRMode) { + return SetTRRModeImpl(aTRRMode); +} + +NS_IMETHODIMP +nsLoadGroup::GetLoadGroup(nsILoadGroup** loadGroup) { + nsCOMPtr<nsILoadGroup> result = mLoadGroup; + result.forget(loadGroup); + return NS_OK; +} + +NS_IMETHODIMP +nsLoadGroup::SetLoadGroup(nsILoadGroup* loadGroup) { + mLoadGroup = loadGroup; + return NS_OK; +} + +//////////////////////////////////////////////////////////////////////////////// +// nsILoadGroup methods: + +NS_IMETHODIMP +nsLoadGroup::GetDefaultLoadRequest(nsIRequest** aRequest) { + nsCOMPtr<nsIRequest> result = mDefaultLoadRequest; + result.forget(aRequest); + return NS_OK; +} + +NS_IMETHODIMP +nsLoadGroup::SetDefaultLoadRequest(nsIRequest* aRequest) { + LOG(("nsLoadGroup::SetDefaultLoadRequest this=%p default-request=%p", this, + aRequest)); + + mDefaultLoadRequest = aRequest; + // Inherit the group load flags from the default load request + if (mDefaultLoadRequest) { + mDefaultLoadRequest->GetLoadFlags(&mLoadFlags); + // + // Mask off any bits that are not part of the nsIRequest flags. + // in particular, nsIChannel::LOAD_DOCUMENT_URI... + // + mLoadFlags &= nsIRequest::LOAD_REQUESTMASK; + + nsCOMPtr<nsITimedChannel> timedChannel = do_QueryInterface(aRequest); + mDefaultLoadIsTimed = timedChannel != nullptr; + if (mDefaultLoadIsTimed) { + timedChannel->GetChannelCreation(&mDefaultRequestCreationTime); + timedChannel->SetTimingEnabled(true); + } + } + // Else, do not change the group's load flags (see bug 95981) + return NS_OK; +} + +NS_IMETHODIMP +nsLoadGroup::AddRequest(nsIRequest* request, nsISupports* ctxt) { + nsresult rv; + + if (MOZ_LOG_TEST(gLoadGroupLog, LogLevel::Debug)) { + nsAutoCString nameStr; + request->GetName(nameStr); + LOG(("LOADGROUP [%p]: Adding request %p %s (count=%d).\n", this, request, + nameStr.get(), mRequests.EntryCount())); + } + + NS_ASSERTION(!mRequests.Search(request), + "Entry added to loadgroup twice, don't do that"); + + // + // Do not add the channel, if the loadgroup is being canceled... + // + if (mIsCanceling) { + LOG( + ("LOADGROUP [%p]: AddChannel() ABORTED because LoadGroup is" + " being canceled!!\n", + this)); + + return NS_BINDING_ABORTED; + } + + nsLoadFlags flags; + // if the request is the default load request or if the default load + // request is null, then the load group should inherit its load flags from + // the request, but also we need to enforce defaultLoadFlags. + if (mDefaultLoadRequest == request || !mDefaultLoadRequest) { + rv = MergeDefaultLoadFlags(request, flags); + } else { + rv = MergeLoadFlags(request, flags); + } + if (NS_FAILED(rv)) return rv; + + // + // Add the request to the list of active requests... + // + + auto entry = static_cast<RequestMapEntry*>(mRequests.Add(request, fallible)); + if (!entry) { + return NS_ERROR_OUT_OF_MEMORY; + } + + if (mPriority != 0) RescheduleRequest(request, mPriority); + + nsCOMPtr<nsITimedChannel> timedChannel = do_QueryInterface(request); + if (timedChannel) timedChannel->SetTimingEnabled(true); + + if (!(flags & nsIRequest::LOAD_BACKGROUND)) { + // Update the count of foreground URIs.. + mForegroundCount += 1; + + // + // Fire the OnStartRequest notification out to the observer... + // + // If the notification fails then DO NOT add the request to + // the load group. + // + nsCOMPtr<nsIRequestObserver> observer = do_QueryReferent(mObserver); + if (observer) { + LOG( + ("LOADGROUP [%p]: Firing OnStartRequest for request %p." + "(foreground count=%d).\n", + this, request, mForegroundCount)); + + rv = observer->OnStartRequest(request); + if (NS_FAILED(rv)) { + LOG(("LOADGROUP [%p]: OnStartRequest for request %p FAILED.\n", this, + request)); + // + // The URI load has been canceled by the observer. Clean up + // the damage... + // + + mRequests.Remove(request); + + rv = NS_OK; + + mForegroundCount -= 1; + } + } + + // Ensure that we're part of our loadgroup while pending + if (mForegroundCount == 1 && mLoadGroup) { + mLoadGroup->AddRequest(this, nullptr); + } + } + + return rv; +} + +NS_IMETHODIMP +nsLoadGroup::RemoveRequest(nsIRequest* request, nsISupports* ctxt, + nsresult aStatus) { + // Make sure we have a owning reference to the request we're about + // to remove. + nsCOMPtr<nsIRequest> kungFuDeathGrip(request); + + nsresult rv = RemoveRequestFromHashtable(request, aStatus); + if (NS_FAILED(rv)) { + return rv; + } + + return NotifyRemovalObservers(request, aStatus); +} + +nsresult nsLoadGroup::RemoveRequestFromHashtable(nsIRequest* request, + nsresult aStatus) { + NS_ENSURE_ARG_POINTER(request); + nsresult rv; + + if (MOZ_LOG_TEST(gLoadGroupLog, LogLevel::Debug)) { + nsAutoCString nameStr; + request->GetName(nameStr); + LOG(("LOADGROUP [%p]: Removing request %p %s status %" PRIx32 + " (count=%d).\n", + this, request, nameStr.get(), static_cast<uint32_t>(aStatus), + mRequests.EntryCount() - 1)); + } + + // + // Remove the request from the group. If this fails, it means that + // the request was *not* in the group so do not update the foreground + // count or it will get messed up... + // + auto entry = static_cast<RequestMapEntry*>(mRequests.Search(request)); + + if (!entry) { + LOG(("LOADGROUP [%p]: Unable to remove request %p. Not in group!\n", this, + request)); + + return NS_ERROR_FAILURE; + } + + mRequests.RemoveEntry(entry); + + // Collect telemetry stats only when default request is a timed channel. + // Don't include failed requests in the timing statistics. + if (mDefaultLoadIsTimed && NS_SUCCEEDED(aStatus)) { + nsCOMPtr<nsITimedChannel> timedChannel = do_QueryInterface(request); + if (timedChannel) { + // Figure out if this request was served from the cache + ++mTimedRequests; + TimeStamp timeStamp; + rv = timedChannel->GetCacheReadStart(&timeStamp); + if (NS_SUCCEEDED(rv) && !timeStamp.IsNull()) { + ++mCachedRequests; + } + + rv = timedChannel->GetAsyncOpen(&timeStamp); + if (NS_SUCCEEDED(rv) && !timeStamp.IsNull()) { + Telemetry::AccumulateTimeDelta( + Telemetry::HTTP_SUBITEM_OPEN_LATENCY_TIME, + mDefaultRequestCreationTime, timeStamp); + } + + rv = timedChannel->GetResponseStart(&timeStamp); + if (NS_SUCCEEDED(rv) && !timeStamp.IsNull()) { + Telemetry::AccumulateTimeDelta( + Telemetry::HTTP_SUBITEM_FIRST_BYTE_LATENCY_TIME, + mDefaultRequestCreationTime, timeStamp); + } + + TelemetryReportChannel(timedChannel, false); + } + } + + if (mRequests.EntryCount() == 0) { + TelemetryReport(); + } + + return NS_OK; +} + +nsresult nsLoadGroup::NotifyRemovalObservers(nsIRequest* request, + nsresult aStatus) { + NS_ENSURE_ARG_POINTER(request); + // Undo any group priority delta... + if (mPriority != 0) RescheduleRequest(request, -mPriority); + + nsLoadFlags flags; + nsresult rv = request->GetLoadFlags(&flags); + if (NS_FAILED(rv)) return rv; + + if (!(flags & nsIRequest::LOAD_BACKGROUND)) { + NS_ASSERTION(mForegroundCount > 0, "ForegroundCount messed up"); + mForegroundCount -= 1; + + // Fire the OnStopRequest out to the observer... + nsCOMPtr<nsIRequestObserver> observer = do_QueryReferent(mObserver); + if (observer) { + LOG( + ("LOADGROUP [%p]: Firing OnStopRequest for request %p." + "(foreground count=%d).\n", + this, request, mForegroundCount)); + + rv = observer->OnStopRequest(request, aStatus); + + if (NS_FAILED(rv)) { + LOG(("LOADGROUP [%p]: OnStopRequest for request %p FAILED.\n", this, + request)); + } + } + + // If that was the last request -> remove ourselves from loadgroup + if (mForegroundCount == 0 && mLoadGroup) { + mLoadGroup->RemoveRequest(this, nullptr, aStatus); + } + } + + return rv; +} + +NS_IMETHODIMP +nsLoadGroup::GetRequests(nsISimpleEnumerator** aRequests) { + nsCOMArray<nsIRequest> requests; + requests.SetCapacity(mRequests.EntryCount()); + + for (auto iter = mRequests.Iter(); !iter.Done(); iter.Next()) { + auto e = static_cast<RequestMapEntry*>(iter.Get()); + requests.AppendObject(e->mKey); + } + + return NS_NewArrayEnumerator(aRequests, requests, NS_GET_IID(nsIRequest)); +} + +NS_IMETHODIMP +nsLoadGroup::SetGroupObserver(nsIRequestObserver* aObserver) { + mObserver = do_GetWeakReference(aObserver); + return NS_OK; +} + +NS_IMETHODIMP +nsLoadGroup::GetGroupObserver(nsIRequestObserver** aResult) { + nsCOMPtr<nsIRequestObserver> observer = do_QueryReferent(mObserver); + observer.forget(aResult); + return NS_OK; +} + +NS_IMETHODIMP +nsLoadGroup::GetActiveCount(uint32_t* aResult) { + *aResult = mForegroundCount; + return NS_OK; +} + +NS_IMETHODIMP +nsLoadGroup::GetNotificationCallbacks(nsIInterfaceRequestor** aCallbacks) { + NS_ENSURE_ARG_POINTER(aCallbacks); + nsCOMPtr<nsIInterfaceRequestor> callbacks = mCallbacks; + callbacks.forget(aCallbacks); + return NS_OK; +} + +NS_IMETHODIMP +nsLoadGroup::SetNotificationCallbacks(nsIInterfaceRequestor* aCallbacks) { + mCallbacks = aCallbacks; + return NS_OK; +} + +NS_IMETHODIMP +nsLoadGroup::GetRequestContextID(uint64_t* aRCID) { + if (!mRequestContext) { + return NS_ERROR_NOT_AVAILABLE; + } + *aRCID = mRequestContext->GetID(); + return NS_OK; +} + +//////////////////////////////////////////////////////////////////////////////// +// nsILoadGroupChild methods: + +NS_IMETHODIMP +nsLoadGroup::GetParentLoadGroup(nsILoadGroup** aParentLoadGroup) { + *aParentLoadGroup = nullptr; + nsCOMPtr<nsILoadGroup> parent = do_QueryReferent(mParentLoadGroup); + if (!parent) return NS_OK; + parent.forget(aParentLoadGroup); + return NS_OK; +} + +NS_IMETHODIMP +nsLoadGroup::SetParentLoadGroup(nsILoadGroup* aParentLoadGroup) { + mParentLoadGroup = do_GetWeakReference(aParentLoadGroup); + return NS_OK; +} + +NS_IMETHODIMP +nsLoadGroup::GetChildLoadGroup(nsILoadGroup** aChildLoadGroup) { + *aChildLoadGroup = do_AddRef(this).take(); + return NS_OK; +} + +NS_IMETHODIMP +nsLoadGroup::GetRootLoadGroup(nsILoadGroup** aRootLoadGroup) { + // first recursively try the root load group of our parent + nsCOMPtr<nsILoadGroupChild> ancestor = do_QueryReferent(mParentLoadGroup); + if (ancestor) return ancestor->GetRootLoadGroup(aRootLoadGroup); + + // next recursively try the root load group of our own load grop + ancestor = do_QueryInterface(mLoadGroup); + if (ancestor) return ancestor->GetRootLoadGroup(aRootLoadGroup); + + // finally just return this + *aRootLoadGroup = do_AddRef(this).take(); + return NS_OK; +} + +//////////////////////////////////////////////////////////////////////////////// +// nsISupportsPriority methods: + +NS_IMETHODIMP +nsLoadGroup::GetPriority(int32_t* aValue) { + *aValue = mPriority; + return NS_OK; +} + +NS_IMETHODIMP +nsLoadGroup::SetPriority(int32_t aValue) { + return AdjustPriority(aValue - mPriority); +} + +NS_IMETHODIMP +nsLoadGroup::AdjustPriority(int32_t aDelta) { + // Update the priority for each request that supports nsISupportsPriority + if (aDelta != 0) { + mPriority += aDelta; + for (auto iter = mRequests.Iter(); !iter.Done(); iter.Next()) { + auto e = static_cast<RequestMapEntry*>(iter.Get()); + RescheduleRequest(e->mKey, aDelta); + } + } + return NS_OK; +} + +NS_IMETHODIMP +nsLoadGroup::GetDefaultLoadFlags(uint32_t* aFlags) { + *aFlags = mDefaultLoadFlags; + return NS_OK; +} + +NS_IMETHODIMP +nsLoadGroup::SetDefaultLoadFlags(uint32_t aFlags) { + mDefaultLoadFlags = aFlags; + return NS_OK; +} + +//////////////////////////////////////////////////////////////////////////////// + +void nsLoadGroup::TelemetryReport() { + nsresult defaultStatus = NS_ERROR_INVALID_ARG; + // We should only report HTTP_PAGE_* telemetry if the defaultRequest was + // actually successful. + if (mDefaultLoadRequest) { + mDefaultLoadRequest->GetStatus(&defaultStatus); + } + if (mDefaultLoadIsTimed && NS_SUCCEEDED(defaultStatus)) { + Telemetry::Accumulate(Telemetry::HTTP_REQUEST_PER_PAGE, mTimedRequests); + if (mTimedRequests) { + Telemetry::Accumulate(Telemetry::HTTP_REQUEST_PER_PAGE_FROM_CACHE, + mCachedRequests * 100 / mTimedRequests); + } + + nsCOMPtr<nsITimedChannel> timedChannel = + do_QueryInterface(mDefaultLoadRequest); + if (timedChannel) TelemetryReportChannel(timedChannel, true); + } + + mTimedRequests = 0; + mCachedRequests = 0; + mDefaultLoadIsTimed = false; +} + +void nsLoadGroup::TelemetryReportChannel(nsITimedChannel* aTimedChannel, + bool aDefaultRequest) { + nsresult rv; + bool timingEnabled; + rv = aTimedChannel->GetTimingEnabled(&timingEnabled); + if (NS_FAILED(rv) || !timingEnabled) return; + + TimeStamp asyncOpen; + rv = aTimedChannel->GetAsyncOpen(&asyncOpen); + // We do not check !asyncOpen.IsNull() bellow, prevent ASSERTIONs this way + if (NS_FAILED(rv) || asyncOpen.IsNull()) return; + + TimeStamp cacheReadStart; + rv = aTimedChannel->GetCacheReadStart(&cacheReadStart); + if (NS_FAILED(rv)) return; + + TimeStamp cacheReadEnd; + rv = aTimedChannel->GetCacheReadEnd(&cacheReadEnd); + if (NS_FAILED(rv)) return; + + TimeStamp domainLookupStart; + rv = aTimedChannel->GetDomainLookupStart(&domainLookupStart); + if (NS_FAILED(rv)) return; + + TimeStamp domainLookupEnd; + rv = aTimedChannel->GetDomainLookupEnd(&domainLookupEnd); + if (NS_FAILED(rv)) return; + + TimeStamp connectStart; + rv = aTimedChannel->GetConnectStart(&connectStart); + if (NS_FAILED(rv)) return; + + TimeStamp secureConnectionStart; + rv = aTimedChannel->GetSecureConnectionStart(&secureConnectionStart); + if (NS_FAILED(rv)) return; + + TimeStamp connectEnd; + rv = aTimedChannel->GetConnectEnd(&connectEnd); + if (NS_FAILED(rv)) return; + + TimeStamp requestStart; + rv = aTimedChannel->GetRequestStart(&requestStart); + if (NS_FAILED(rv)) return; + + TimeStamp responseStart; + rv = aTimedChannel->GetResponseStart(&responseStart); + if (NS_FAILED(rv)) return; + + TimeStamp responseEnd; + rv = aTimedChannel->GetResponseEnd(&responseEnd); + if (NS_FAILED(rv)) return; + + bool useHttp3 = false; + bool supportHttp3 = false; + nsCOMPtr<nsIHttpChannelInternal> httpChannel = + do_QueryInterface(aTimedChannel); + if (httpChannel) { + uint32_t major; + uint32_t minor; + if (NS_SUCCEEDED(httpChannel->GetResponseVersion(&major, &minor))) { + useHttp3 = major == 3; + if (major == 2) { + if (NS_FAILED(httpChannel->GetSupportsHTTP3(&supportHttp3))) { + supportHttp3 = false; + } + } + } + } + +#define HTTP_REQUEST_HISTOGRAMS(prefix) \ + if (!domainLookupStart.IsNull()) { \ + Telemetry::AccumulateTimeDelta(Telemetry::HTTP_##prefix##_DNS_ISSUE_TIME, \ + asyncOpen, domainLookupStart); \ + } \ + \ + if (!domainLookupStart.IsNull() && !domainLookupEnd.IsNull()) { \ + Telemetry::AccumulateTimeDelta(Telemetry::HTTP_##prefix##_DNS_LOOKUP_TIME, \ + domainLookupStart, domainLookupEnd); \ + } \ + \ + if (!secureConnectionStart.IsNull() && !connectEnd.IsNull()) { \ + Telemetry::AccumulateTimeDelta(Telemetry::HTTP_##prefix##_TLS_HANDSHAKE, \ + secureConnectionStart, connectEnd); \ + } \ + \ + if (!connectStart.IsNull() && !connectEnd.IsNull()) { \ + Telemetry::AccumulateTimeDelta( \ + Telemetry::HTTP_##prefix##_TCP_CONNECTION_2, connectStart, \ + connectEnd); \ + } \ + \ + if (!requestStart.IsNull() && !responseEnd.IsNull()) { \ + Telemetry::AccumulateTimeDelta( \ + Telemetry::HTTP_##prefix##_OPEN_TO_FIRST_SENT, asyncOpen, \ + requestStart); \ + \ + Telemetry::AccumulateTimeDelta( \ + Telemetry::HTTP_##prefix##_FIRST_SENT_TO_LAST_RECEIVED, requestStart, \ + responseEnd); \ + \ + if (cacheReadStart.IsNull() && !responseStart.IsNull()) { \ + Telemetry::AccumulateTimeDelta( \ + Telemetry::HTTP_##prefix##_OPEN_TO_FIRST_RECEIVED, asyncOpen, \ + responseStart); \ + } \ + } \ + \ + if (!cacheReadStart.IsNull() && !cacheReadEnd.IsNull()) { \ + Telemetry::AccumulateTimeDelta( \ + Telemetry::HTTP_##prefix##_OPEN_TO_FIRST_FROM_CACHE_V2, asyncOpen, \ + cacheReadStart); \ + \ + Telemetry::AccumulateTimeDelta( \ + Telemetry::HTTP_##prefix##_CACHE_READ_TIME_V2, cacheReadStart, \ + cacheReadEnd); \ + \ + if (!requestStart.IsNull() && !responseEnd.IsNull()) { \ + Telemetry::AccumulateTimeDelta(Telemetry::HTTP_##prefix##_REVALIDATION, \ + requestStart, responseEnd); \ + } \ + } \ + \ + if (!cacheReadEnd.IsNull()) { \ + Telemetry::AccumulateTimeDelta( \ + Telemetry::HTTP_##prefix##_COMPLETE_LOAD_V2, asyncOpen, cacheReadEnd); \ + Telemetry::AccumulateTimeDelta( \ + Telemetry::HTTP_##prefix##_COMPLETE_LOAD_CACHED_V2, asyncOpen, \ + cacheReadEnd); \ + } else if (!responseEnd.IsNull()) { \ + Telemetry::AccumulateTimeDelta( \ + Telemetry::HTTP_##prefix##_COMPLETE_LOAD_V2, asyncOpen, responseEnd); \ + Telemetry::AccumulateTimeDelta( \ + Telemetry::HTTP_##prefix##_COMPLETE_LOAD_NET_V2, asyncOpen, \ + responseEnd); \ + } + + if (aDefaultRequest) { + HTTP_REQUEST_HISTOGRAMS(PAGE) + } else { + HTTP_REQUEST_HISTOGRAMS(SUB) + } + + if ((useHttp3 || supportHttp3) && cacheReadStart.IsNull() && + cacheReadEnd.IsNull()) { + nsCString key = (useHttp3) ? ((aDefaultRequest) ? "uses_http3_page"_ns + : "uses_http3_sub"_ns) + : ((aDefaultRequest) ? "supports_http3_page"_ns + : "supports_http3_sub"_ns); + + if (!secureConnectionStart.IsNull() && !connectEnd.IsNull()) { + Telemetry::AccumulateTimeDelta(Telemetry::HTTP3_TLS_HANDSHAKE, key, + secureConnectionStart, connectEnd); + } + + if (supportHttp3 && !connectStart.IsNull() && !connectEnd.IsNull()) { + Telemetry::AccumulateTimeDelta(Telemetry::SUP_HTTP3_TCP_CONNECTION, key, + connectStart, connectEnd); + } + + if (!requestStart.IsNull() && !responseEnd.IsNull()) { + Telemetry::AccumulateTimeDelta(Telemetry::HTTP3_OPEN_TO_FIRST_SENT, key, + asyncOpen, requestStart); + + Telemetry::AccumulateTimeDelta( + Telemetry::HTTP3_FIRST_SENT_TO_LAST_RECEIVED, key, requestStart, + responseEnd); + + if (!responseStart.IsNull()) { + Telemetry::AccumulateTimeDelta(Telemetry::HTTP3_OPEN_TO_FIRST_RECEIVED, + key, asyncOpen, responseStart); + } + + if (!responseEnd.IsNull()) { + Telemetry::AccumulateTimeDelta(Telemetry::HTTP3_COMPLETE_LOAD, key, + asyncOpen, responseEnd); + } + } + } + +#undef HTTP_REQUEST_HISTOGRAMS +} + +nsresult nsLoadGroup::MergeLoadFlags(nsIRequest* aRequest, + nsLoadFlags& outFlags) { + nsresult rv; + nsLoadFlags flags, oldFlags; + + rv = aRequest->GetLoadFlags(&flags); + if (NS_FAILED(rv)) { + return rv; + } + + oldFlags = flags; + + // Inherit the following bits... + flags |= (mLoadFlags & + (LOAD_BACKGROUND | LOAD_BYPASS_CACHE | LOAD_FROM_CACHE | + VALIDATE_ALWAYS | VALIDATE_ONCE_PER_SESSION | VALIDATE_NEVER)); + + // ... and force the default flags. + flags |= mDefaultLoadFlags; + + if (flags != oldFlags) { + rv = aRequest->SetLoadFlags(flags); + } + + outFlags = flags; + return rv; +} + +nsresult nsLoadGroup::MergeDefaultLoadFlags(nsIRequest* aRequest, + nsLoadFlags& outFlags) { + nsresult rv; + nsLoadFlags flags, oldFlags; + + rv = aRequest->GetLoadFlags(&flags); + if (NS_FAILED(rv)) { + return rv; + } + + oldFlags = flags; + // ... and force the default flags. + flags |= mDefaultLoadFlags; + + if (flags != oldFlags) { + rv = aRequest->SetLoadFlags(flags); + } + outFlags = flags; + return rv; +} + +nsresult nsLoadGroup::Init() { + mRequestContextService = RequestContextService::GetOrCreate(); + if (mRequestContextService) { + Unused << mRequestContextService->NewRequestContext( + getter_AddRefs(mRequestContext)); + } + + nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService(); + NS_ENSURE_STATE(os); + + Unused << os->AddObserver(this, "last-pb-context-exited", true); + + return NS_OK; +} + +nsresult nsLoadGroup::InitWithRequestContextId( + const uint64_t& aRequestContextId) { + mRequestContextService = RequestContextService::GetOrCreate(); + if (mRequestContextService) { + Unused << mRequestContextService->GetRequestContext( + aRequestContextId, getter_AddRefs(mRequestContext)); + } + mExternalRequestContext = true; + + nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService(); + NS_ENSURE_STATE(os); + + Unused << os->AddObserver(this, "last-pb-context-exited", true); + + return NS_OK; +} + +NS_IMETHODIMP +nsLoadGroup::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) { + MOZ_ASSERT(!strcmp(aTopic, "last-pb-context-exited")); + + OriginAttributes attrs; + StoragePrincipalHelper::GetRegularPrincipalOriginAttributes(this, attrs); + if (attrs.mPrivateBrowsingId == 0) { + return NS_OK; + } + + mBrowsingContextDiscarded = true; + return NS_OK; +} + +NS_IMETHODIMP +nsLoadGroup::GetIsBrowsingContextDiscarded(bool* aIsBrowsingContextDiscarded) { + *aIsBrowsingContextDiscarded = mBrowsingContextDiscarded; + return NS_OK; +} + +} // namespace net +} // namespace mozilla + +#undef LOG diff --git a/netwerk/base/nsLoadGroup.h b/netwerk/base/nsLoadGroup.h new file mode 100644 index 0000000000..c419b742c6 --- /dev/null +++ b/netwerk/base/nsLoadGroup.h @@ -0,0 +1,107 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef nsLoadGroup_h__ +#define nsLoadGroup_h__ + +#include "nsILoadGroup.h" +#include "nsILoadGroupChild.h" +#include "nsIObserver.h" +#include "nsCOMPtr.h" +#include "nsWeakReference.h" +#include "nsISupportsPriority.h" +#include "PLDHashTable.h" +#include "mozilla/TimeStamp.h" + +class nsIRequestContext; +class nsIRequestContextService; +class nsITimedChannel; + +namespace mozilla { +namespace net { + +class nsLoadGroup : public nsILoadGroup, + public nsILoadGroupChild, + public nsIObserver, + public nsISupportsPriority, + public nsSupportsWeakReference { + public: + NS_DECL_ISUPPORTS + + //////////////////////////////////////////////////////////////////////////// + // nsIRequest methods: + NS_DECL_NSIREQUEST + + //////////////////////////////////////////////////////////////////////////// + // nsILoadGroup methods: + NS_DECL_NSILOADGROUP + + //////////////////////////////////////////////////////////////////////////// + // nsILoadGroupChild methods: + NS_DECL_NSILOADGROUPCHILD + + //////////////////////////////////////////////////////////////////////////// + // nsISupportsPriority methods: + NS_DECL_NSISUPPORTSPRIORITY + + //////////////////////////////////////////////////////////////////////////// + // nsIObserver methods: + NS_DECL_NSIOBSERVER + + //////////////////////////////////////////////////////////////////////////// + // nsLoadGroup methods: + + nsLoadGroup(); + + nsresult Init(); + nsresult InitWithRequestContextId(const uint64_t& aRequestContextId); + + protected: + virtual ~nsLoadGroup(); + + nsresult MergeLoadFlags(nsIRequest* aRequest, nsLoadFlags& flags); + nsresult MergeDefaultLoadFlags(nsIRequest* aRequest, nsLoadFlags& flags); + + private: + void TelemetryReport(); + void TelemetryReportChannel(nsITimedChannel* timedChannel, + bool defaultRequest); + + nsresult RemoveRequestFromHashtable(nsIRequest* aRequest, nsresult aStatus); + nsresult NotifyRemovalObservers(nsIRequest* aRequest, nsresult aStatus); + + protected: + uint32_t mForegroundCount; + uint32_t mLoadFlags; + uint32_t mDefaultLoadFlags; + int32_t mPriority; + + nsCOMPtr<nsILoadGroup> mLoadGroup; // load groups can contain load groups + nsCOMPtr<nsIInterfaceRequestor> mCallbacks; + nsCOMPtr<nsIRequestContext> mRequestContext; + nsCOMPtr<nsIRequestContextService> mRequestContextService; + + nsCOMPtr<nsIRequest> mDefaultLoadRequest; + PLDHashTable mRequests; + + nsWeakPtr mObserver; + nsWeakPtr mParentLoadGroup; + + nsresult mStatus; + bool mIsCanceling; + bool mDefaultLoadIsTimed; + bool mBrowsingContextDiscarded; + bool mExternalRequestContext; + + /* Telemetry */ + mozilla::TimeStamp mDefaultRequestCreationTime; + uint32_t mTimedRequests; + uint32_t mCachedRequests; +}; + +} // namespace net +} // namespace mozilla + +#endif // nsLoadGroup_h__ diff --git a/netwerk/base/nsMIMEInputStream.cpp b/netwerk/base/nsMIMEInputStream.cpp new file mode 100644 index 0000000000..13b6ad0ac1 --- /dev/null +++ b/netwerk/base/nsMIMEInputStream.cpp @@ -0,0 +1,536 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +/** + * The MIME stream separates headers and a datastream. It also allows + * automatic creation of the content-length header. + */ + +#include "nsMIMEInputStream.h" + +#include <utility> + +#include "ipc/IPCMessageUtils.h" +#include "mozilla/Mutex.h" +#include "mozilla/ipc/InputStreamUtils.h" +#include "nsCOMPtr.h" +#include "nsComponentManagerUtils.h" +#include "nsIAsyncInputStream.h" +#include "nsIClassInfoImpl.h" +#include "nsIHttpHeaderVisitor.h" +#include "nsIIPCSerializableInputStream.h" +#include "nsIInputStreamLength.h" +#include "nsIMIMEInputStream.h" +#include "nsISeekableStream.h" +#include "nsString.h" + +using namespace mozilla::ipc; +using mozilla::Maybe; + +class nsMIMEInputStream : public nsIMIMEInputStream, + public nsISeekableStream, + public nsIIPCSerializableInputStream, + public nsIAsyncInputStream, + public nsIInputStreamCallback, + public nsIInputStreamLength, + public nsIAsyncInputStreamLength, + public nsIInputStreamLengthCallback, + public nsICloneableInputStream { + virtual ~nsMIMEInputStream() = default; + + public: + nsMIMEInputStream(); + + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIINPUTSTREAM + NS_DECL_NSIMIMEINPUTSTREAM + NS_DECL_NSISEEKABLESTREAM + NS_DECL_NSITELLABLESTREAM + NS_DECL_NSIIPCSERIALIZABLEINPUTSTREAM + NS_DECL_NSIASYNCINPUTSTREAM + NS_DECL_NSIINPUTSTREAMCALLBACK + NS_DECL_NSIINPUTSTREAMLENGTH + NS_DECL_NSIASYNCINPUTSTREAMLENGTH + NS_DECL_NSIINPUTSTREAMLENGTHCALLBACK + NS_DECL_NSICLONEABLEINPUTSTREAM + + private: + void InitStreams(); + + template <typename M> + void SerializeInternal(InputStreamParams& aParams, + FileDescriptorArray& aFileDescriptors, + bool aDelayedStart, uint32_t aMaxSize, + uint32_t* aSizeUsed, M* aManager); + + struct MOZ_STACK_CLASS ReadSegmentsState { + nsCOMPtr<nsIInputStream> mThisStream; + nsWriteSegmentFun mWriter; + void* mClosure; + }; + static nsresult ReadSegCb(nsIInputStream* aIn, void* aClosure, + const char* aFromRawSegment, uint32_t aToOffset, + uint32_t aCount, uint32_t* aWriteCount); + + bool IsSeekableInputStream() const; + bool IsAsyncInputStream() const; + bool IsInputStreamLength() const; + bool IsAsyncInputStreamLength() const; + bool IsCloneableInputStream() const; + + nsTArray<HeaderEntry> mHeaders; + + nsCOMPtr<nsIInputStream> mStream; + bool mStartedReading; + + mozilla::Mutex mMutex; + + // This is protected by mutex. + nsCOMPtr<nsIInputStreamCallback> mAsyncWaitCallback; + + // This is protected by mutex. + nsCOMPtr<nsIInputStreamLengthCallback> mAsyncInputStreamLengthCallback; +}; + +NS_IMPL_ADDREF(nsMIMEInputStream) +NS_IMPL_RELEASE(nsMIMEInputStream) + +NS_IMPL_CLASSINFO(nsMIMEInputStream, nullptr, nsIClassInfo::THREADSAFE, + NS_MIMEINPUTSTREAM_CID) + +NS_INTERFACE_MAP_BEGIN(nsMIMEInputStream) + NS_INTERFACE_MAP_ENTRY(nsIMIMEInputStream) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsIInputStream, nsIMIMEInputStream) + NS_INTERFACE_MAP_ENTRY(nsITellableStream) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsISeekableStream, IsSeekableInputStream()) + NS_INTERFACE_MAP_ENTRY(nsIIPCSerializableInputStream) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAsyncInputStream, IsAsyncInputStream()) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIInputStreamCallback, + IsAsyncInputStream()) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIMIMEInputStream) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIInputStreamLength, + IsInputStreamLength()) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAsyncInputStreamLength, + IsAsyncInputStreamLength()) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIInputStreamLengthCallback, + IsAsyncInputStreamLength()) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsICloneableInputStream, + IsCloneableInputStream()) + NS_IMPL_QUERY_CLASSINFO(nsMIMEInputStream) +NS_INTERFACE_MAP_END + +NS_IMPL_CI_INTERFACE_GETTER(nsMIMEInputStream, nsIMIMEInputStream, + nsIAsyncInputStream, nsIInputStream, + nsISeekableStream, nsITellableStream) + +nsMIMEInputStream::nsMIMEInputStream() + : mStartedReading(false), mMutex("nsMIMEInputStream::mMutex") {} + +NS_IMETHODIMP +nsMIMEInputStream::AddHeader(const char* aName, const char* aValue) { + NS_ENSURE_FALSE(mStartedReading, NS_ERROR_FAILURE); + + HeaderEntry* entry = mHeaders.AppendElement(); + entry->name().Append(aName); + entry->value().Append(aValue); + + return NS_OK; +} + +NS_IMETHODIMP +nsMIMEInputStream::VisitHeaders(nsIHttpHeaderVisitor* visitor) { + nsresult rv; + + for (auto& header : mHeaders) { + rv = visitor->VisitHeader(header.name(), header.value()); + if (NS_FAILED(rv)) { + return rv; + } + } + return NS_OK; +} + +NS_IMETHODIMP +nsMIMEInputStream::SetData(nsIInputStream* aStream) { + NS_ENSURE_FALSE(mStartedReading, NS_ERROR_FAILURE); + + nsCOMPtr<nsISeekableStream> seekable = do_QueryInterface(aStream); + if (!seekable) { + return NS_ERROR_INVALID_ARG; + } + + mStream = aStream; + return NS_OK; +} + +NS_IMETHODIMP +nsMIMEInputStream::GetData(nsIInputStream** aStream) { + NS_ENSURE_ARG_POINTER(aStream); + *aStream = mStream; + NS_IF_ADDREF(*aStream); + return NS_OK; +} + +// set up the internal streams +void nsMIMEInputStream::InitStreams() { + NS_ASSERTION(!mStartedReading, + "Don't call initStreams twice without rewinding"); + + mStartedReading = true; +} + +#define INITSTREAMS \ + if (!mStartedReading) { \ + NS_ENSURE_TRUE(mStream, NS_ERROR_UNEXPECTED); \ + InitStreams(); \ + } + +// Reset mStartedReading when Seek-ing to start +NS_IMETHODIMP +nsMIMEInputStream::Seek(int32_t whence, int64_t offset) { + NS_ENSURE_TRUE(mStream, NS_ERROR_UNEXPECTED); + + nsresult rv; + nsCOMPtr<nsISeekableStream> stream = do_QueryInterface(mStream); + + if (whence == NS_SEEK_SET && offset == 0) { + rv = stream->Seek(whence, offset); + if (NS_SUCCEEDED(rv)) mStartedReading = false; + } else { + INITSTREAMS; + rv = stream->Seek(whence, offset); + } + + return rv; +} + +// Proxy ReadSegments since we need to be a good little nsIInputStream +NS_IMETHODIMP nsMIMEInputStream::ReadSegments(nsWriteSegmentFun aWriter, + void* aClosure, uint32_t aCount, + uint32_t* _retval) { + INITSTREAMS; + ReadSegmentsState state; + // Disambiguate ambiguous nsIInputStream. + state.mThisStream = + static_cast<nsIInputStream*>(static_cast<nsIMIMEInputStream*>(this)); + state.mWriter = aWriter; + state.mClosure = aClosure; + return mStream->ReadSegments(ReadSegCb, &state, aCount, _retval); +} + +nsresult nsMIMEInputStream::ReadSegCb(nsIInputStream* aIn, void* aClosure, + const char* aFromRawSegment, + uint32_t aToOffset, uint32_t aCount, + uint32_t* aWriteCount) { + ReadSegmentsState* state = (ReadSegmentsState*)aClosure; + return (state->mWriter)(state->mThisStream, state->mClosure, aFromRawSegment, + aToOffset, aCount, aWriteCount); +} + +/** + * Forward everything else to the mStream after calling InitStreams() + */ + +// nsIInputStream +NS_IMETHODIMP nsMIMEInputStream::Close(void) { + INITSTREAMS; + return mStream->Close(); +} +NS_IMETHODIMP nsMIMEInputStream::Available(uint64_t* _retval) { + INITSTREAMS; + return mStream->Available(_retval); +} +NS_IMETHODIMP nsMIMEInputStream::Read(char* buf, uint32_t count, + uint32_t* _retval) { + INITSTREAMS; + return mStream->Read(buf, count, _retval); +} +NS_IMETHODIMP nsMIMEInputStream::IsNonBlocking(bool* aNonBlocking) { + INITSTREAMS; + return mStream->IsNonBlocking(aNonBlocking); +} + +// nsIAsyncInputStream +NS_IMETHODIMP +nsMIMEInputStream::CloseWithStatus(nsresult aStatus) { + INITSTREAMS; + nsCOMPtr<nsIAsyncInputStream> asyncStream = do_QueryInterface(mStream); + return asyncStream->CloseWithStatus(aStatus); +} + +NS_IMETHODIMP +nsMIMEInputStream::AsyncWait(nsIInputStreamCallback* aCallback, uint32_t aFlags, + uint32_t aRequestedCount, + nsIEventTarget* aEventTarget) { + INITSTREAMS; + nsCOMPtr<nsIAsyncInputStream> asyncStream = do_QueryInterface(mStream); + if (NS_WARN_IF(!asyncStream)) { + return NS_ERROR_FAILURE; + } + + nsCOMPtr<nsIInputStreamCallback> callback = aCallback ? this : nullptr; + { + MutexAutoLock lock(mMutex); + if (mAsyncWaitCallback && aCallback) { + return NS_ERROR_FAILURE; + } + + mAsyncWaitCallback = aCallback; + } + + return asyncStream->AsyncWait(callback, aFlags, aRequestedCount, + aEventTarget); +} + +// nsIInputStreamCallback + +NS_IMETHODIMP +nsMIMEInputStream::OnInputStreamReady(nsIAsyncInputStream* aStream) { + nsCOMPtr<nsIInputStreamCallback> callback; + + { + MutexAutoLock lock(mMutex); + + // We have been canceled in the meanwhile. + if (!mAsyncWaitCallback) { + return NS_OK; + } + + callback.swap(mAsyncWaitCallback); + } + + MOZ_ASSERT(callback); + return callback->OnInputStreamReady(this); +} + +// nsITellableStream +NS_IMETHODIMP nsMIMEInputStream::Tell(int64_t* _retval) { + INITSTREAMS; + nsCOMPtr<nsITellableStream> stream = do_QueryInterface(mStream); + return stream->Tell(_retval); +} + +// nsISeekableStream +NS_IMETHODIMP nsMIMEInputStream::SetEOF(void) { + INITSTREAMS; + nsCOMPtr<nsISeekableStream> stream = do_QueryInterface(mStream); + return stream->SetEOF(); +} + +/** + * Factory method used by do_CreateInstance + */ + +nsresult nsMIMEInputStreamConstructor(nsISupports* outer, REFNSIID iid, + void** result) { + *result = nullptr; + + if (outer) return NS_ERROR_NO_AGGREGATION; + + RefPtr<nsMIMEInputStream> inst = new nsMIMEInputStream(); + if (!inst) return NS_ERROR_OUT_OF_MEMORY; + + return inst->QueryInterface(iid, result); +} + +void nsMIMEInputStream::Serialize( + InputStreamParams& aParams, FileDescriptorArray& aFileDescriptors, + bool aDelayedStart, uint32_t aMaxSize, uint32_t* aSizeUsed, + mozilla::ipc::ParentToChildStreamActorManager* aManager) { + SerializeInternal(aParams, aFileDescriptors, aDelayedStart, aMaxSize, + aSizeUsed, aManager); +} + +void nsMIMEInputStream::Serialize( + InputStreamParams& aParams, FileDescriptorArray& aFileDescriptors, + bool aDelayedStart, uint32_t aMaxSize, uint32_t* aSizeUsed, + mozilla::ipc::ChildToParentStreamActorManager* aManager) { + SerializeInternal(aParams, aFileDescriptors, aDelayedStart, aMaxSize, + aSizeUsed, aManager); +} + +template <typename M> +void nsMIMEInputStream::SerializeInternal(InputStreamParams& aParams, + FileDescriptorArray& aFileDescriptors, + bool aDelayedStart, uint32_t aMaxSize, + uint32_t* aSizeUsed, M* aManager) { + MOZ_ASSERT(aSizeUsed); + *aSizeUsed = 0; + + MIMEInputStreamParams params; + params.headers() = mHeaders.Clone(); + params.startedReading() = mStartedReading; + + if (!mStream) { + aParams = params; + return; + } + + InputStreamParams wrappedParams; + + if (nsCOMPtr<nsIIPCSerializableInputStream> serializable = + do_QueryInterface(mStream)) { + InputStreamHelper::SerializeInputStream(mStream, wrappedParams, + aFileDescriptors, aDelayedStart, + aMaxSize, aSizeUsed, aManager); + } else { + // Falling back to sending the underlying stream over a pipe when + // sending an nsMIMEInputStream over IPC is potentially wasteful + // if it is sent several times. This can possibly happen with + // fission. There are two ways to improve this, see bug 1648369 + // and bug 1648370. + InputStreamHelper::SerializeInputStreamAsPipe(mStream, wrappedParams, + aDelayedStart, aManager); + } + + NS_ASSERTION(wrappedParams.type() != InputStreamParams::T__None, + "Wrapped stream failed to serialize!"); + + params.optionalStream().emplace(wrappedParams); + aParams = params; +} + +bool nsMIMEInputStream::Deserialize( + const InputStreamParams& aParams, + const FileDescriptorArray& aFileDescriptors) { + if (aParams.type() != InputStreamParams::TMIMEInputStreamParams) { + NS_ERROR("Received unknown parameters from the other process!"); + return false; + } + + const MIMEInputStreamParams& params = aParams.get_MIMEInputStreamParams(); + const Maybe<InputStreamParams>& wrappedParams = params.optionalStream(); + + mHeaders = params.headers().Clone(); + mStartedReading = params.startedReading(); + + if (wrappedParams.isSome()) { + nsCOMPtr<nsIInputStream> stream; + stream = InputStreamHelper::DeserializeInputStream(wrappedParams.ref(), + aFileDescriptors); + if (!stream) { + NS_WARNING("Failed to deserialize wrapped stream!"); + return false; + } + + mStream = stream; + } + + return true; +} + +NS_IMETHODIMP +nsMIMEInputStream::Length(int64_t* aLength) { + nsCOMPtr<nsIInputStreamLength> stream = do_QueryInterface(mStream); + if (NS_WARN_IF(!stream)) { + return NS_ERROR_FAILURE; + } + + return stream->Length(aLength); +} + +NS_IMETHODIMP +nsMIMEInputStream::AsyncLengthWait(nsIInputStreamLengthCallback* aCallback, + nsIEventTarget* aEventTarget) { + nsCOMPtr<nsIAsyncInputStreamLength> stream = do_QueryInterface(mStream); + if (NS_WARN_IF(!stream)) { + return NS_ERROR_FAILURE; + } + + nsCOMPtr<nsIInputStreamLengthCallback> callback = aCallback ? this : nullptr; + { + MutexAutoLock lock(mMutex); + mAsyncInputStreamLengthCallback = aCallback; + } + + return stream->AsyncLengthWait(callback, aEventTarget); +} + +NS_IMETHODIMP +nsMIMEInputStream::OnInputStreamLengthReady(nsIAsyncInputStreamLength* aStream, + int64_t aLength) { + nsCOMPtr<nsIInputStreamLengthCallback> callback; + { + MutexAutoLock lock(mMutex); + // We have been canceled in the meanwhile. + if (!mAsyncInputStreamLengthCallback) { + return NS_OK; + } + + callback.swap(mAsyncInputStreamLengthCallback); + } + + MOZ_ASSERT(callback); + return callback->OnInputStreamLengthReady(this, aLength); +} + +bool nsMIMEInputStream::IsSeekableInputStream() const { + nsCOMPtr<nsISeekableStream> seekable = do_QueryInterface(mStream); + return !!seekable; +} + +bool nsMIMEInputStream::IsAsyncInputStream() const { + nsCOMPtr<nsIAsyncInputStream> asyncStream = do_QueryInterface(mStream); + return !!asyncStream; +} + +bool nsMIMEInputStream::IsInputStreamLength() const { + nsCOMPtr<nsIInputStreamLength> stream = do_QueryInterface(mStream); + return !!stream; +} + +bool nsMIMEInputStream::IsAsyncInputStreamLength() const { + nsCOMPtr<nsIAsyncInputStreamLength> stream = do_QueryInterface(mStream); + return !!stream; +} + +bool nsMIMEInputStream::IsCloneableInputStream() const { + nsCOMPtr<nsICloneableInputStream> stream = do_QueryInterface(mStream); + return !!stream; +} + +// nsICloneableInputStream interface + +NS_IMETHODIMP +nsMIMEInputStream::GetCloneable(bool* aCloneable) { + nsCOMPtr<nsICloneableInputStream> stream = do_QueryInterface(mStream); + if (!mStream) { + return NS_ERROR_FAILURE; + } + + return stream->GetCloneable(aCloneable); +} + +NS_IMETHODIMP +nsMIMEInputStream::Clone(nsIInputStream** aResult) { + nsCOMPtr<nsICloneableInputStream> stream = do_QueryInterface(mStream); + if (!mStream) { + return NS_ERROR_FAILURE; + } + + nsCOMPtr<nsIInputStream> clonedStream; + nsresult rv = stream->Clone(getter_AddRefs(clonedStream)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + nsCOMPtr<nsIMIMEInputStream> mimeStream = new nsMIMEInputStream(); + + rv = mimeStream->SetData(clonedStream); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + for (const HeaderEntry& entry : mHeaders) { + rv = mimeStream->AddHeader(entry.name().get(), entry.value().get()); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + } + + static_cast<nsMIMEInputStream*>(mimeStream.get())->mStartedReading = + mStartedReading; + + mimeStream.forget(aResult); + return NS_OK; +} diff --git a/netwerk/base/nsMIMEInputStream.h b/netwerk/base/nsMIMEInputStream.h new file mode 100644 index 0000000000..fde9995304 --- /dev/null +++ b/netwerk/base/nsMIMEInputStream.h @@ -0,0 +1,25 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +/** + * The MIME stream separates headers and a datastream. It also allows + * automatic creation of the content-length header. + */ + +#ifndef _nsMIMEInputStream_h_ +#define _nsMIMEInputStream_h_ + +#define NS_MIMEINPUTSTREAM_CONTRACTID "@mozilla.org/network/mime-input-stream;1" +#define NS_MIMEINPUTSTREAM_CID \ + { /* 58a1c31c-1dd2-11b2-a3f6-d36949d48268 */ \ + 0x58a1c31c, 0x1dd2, 0x11b2, { \ + 0xa3, 0xf6, 0xd3, 0x69, 0x49, 0xd4, 0x82, 0x68 \ + } \ + } + +extern nsresult nsMIMEInputStreamConstructor(nsISupports* outer, REFNSIID iid, + void** result); + +#endif // _nsMIMEInputStream_h_ diff --git a/netwerk/base/nsMediaFragmentURIParser.cpp b/netwerk/base/nsMediaFragmentURIParser.cpp new file mode 100644 index 0000000000..9252c24263 --- /dev/null +++ b/netwerk/base/nsMediaFragmentURIParser.cpp @@ -0,0 +1,353 @@ +/* -*- 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 "nsTArray.h" +#include "nsCharSeparatedTokenizer.h" +#include "nsEscape.h" +#include "nsIURI.h" +#include <utility> + +#include "nsMediaFragmentURIParser.h" + +using std::make_pair; +using std::pair; + +namespace mozilla { +namespace net { + +nsMediaFragmentURIParser::nsMediaFragmentURIParser(nsIURI* aURI) + : mClipUnit(eClipUnit_Pixel) { + nsAutoCString ref; + aURI->GetRef(ref); + Parse(ref); +} + +nsMediaFragmentURIParser::nsMediaFragmentURIParser(nsCString& aRef) + : mClipUnit(eClipUnit_Pixel) { + Parse(aRef); +} + +bool nsMediaFragmentURIParser::ParseNPT(nsDependentSubstring aString) { + nsDependentSubstring original(aString); + if (aString.Length() > 4 && aString[0] == 'n' && aString[1] == 'p' && + aString[2] == 't' && aString[3] == ':') { + aString.Rebind(aString, 4); + } + + if (aString.Length() == 0) { + return false; + } + + double start = -1.0; + double end = -1.0; + + ParseNPTTime(aString, start); + + if (aString.Length() == 0) { + mStart.emplace(start); + return true; + } + + if (aString[0] != ',') { + aString.Rebind(original, 0); + return false; + } + + aString.Rebind(aString, 1); + + if (aString.Length() == 0) { + aString.Rebind(original, 0); + return false; + } + + ParseNPTTime(aString, end); + + if (end <= start || aString.Length() != 0) { + aString.Rebind(original, 0); + return false; + } + + mStart.emplace(start); + mEnd.emplace(end); + return true; +} + +bool nsMediaFragmentURIParser::ParseNPTTime(nsDependentSubstring& aString, + double& aTime) { + if (aString.Length() == 0) { + return false; + } + + return ParseNPTHHMMSS(aString, aTime) || ParseNPTMMSS(aString, aTime) || + ParseNPTSec(aString, aTime); +} + +// Return true if the given character is a numeric character +static bool IsDigit(nsDependentSubstring::char_type aChar) { + return (aChar >= '0' && aChar <= '9'); +} + +// Return the index of the first character in the string that is not +// a numerical digit, starting from 'aStart'. +static uint32_t FirstNonDigit(nsDependentSubstring& aString, uint32_t aStart) { + while (aStart < aString.Length() && IsDigit(aString[aStart])) { + ++aStart; + } + return aStart; +} + +bool nsMediaFragmentURIParser::ParseNPTSec(nsDependentSubstring& aString, + double& aSec) { + nsDependentSubstring original(aString); + if (aString.Length() == 0) { + return false; + } + + uint32_t index = FirstNonDigit(aString, 0); + if (index == 0) { + return false; + } + + nsDependentSubstring n(aString, 0, index); + nsresult ec; + int32_t s = n.ToInteger(&ec); + if (NS_FAILED(ec)) { + return false; + } + + aString.Rebind(aString, index); + double fraction = 0.0; + if (!ParseNPTFraction(aString, fraction)) { + aString.Rebind(original, 0); + return false; + } + + aSec = s + fraction; + return true; +} + +bool nsMediaFragmentURIParser::ParseNPTMMSS(nsDependentSubstring& aString, + double& aTime) { + nsDependentSubstring original(aString); + uint32_t mm = 0; + uint32_t ss = 0; + double fraction = 0.0; + if (!ParseNPTMM(aString, mm)) { + aString.Rebind(original, 0); + return false; + } + + if (aString.Length() < 2 || aString[0] != ':') { + aString.Rebind(original, 0); + return false; + } + + aString.Rebind(aString, 1); + if (!ParseNPTSS(aString, ss)) { + aString.Rebind(original, 0); + return false; + } + + if (!ParseNPTFraction(aString, fraction)) { + aString.Rebind(original, 0); + return false; + } + aTime = mm * 60 + ss + fraction; + return true; +} + +bool nsMediaFragmentURIParser::ParseNPTFraction(nsDependentSubstring& aString, + double& aFraction) { + double fraction = 0.0; + + if (aString.Length() > 0 && aString[0] == '.') { + uint32_t index = FirstNonDigit(aString, 1); + + if (index > 1) { + nsDependentSubstring number(aString, 0, index); + nsresult ec; + fraction = PromiseFlatString(number).ToDouble(&ec); + if (NS_FAILED(ec)) { + return false; + } + } + aString.Rebind(aString, index); + } + + aFraction = fraction; + return true; +} + +bool nsMediaFragmentURIParser::ParseNPTHHMMSS(nsDependentSubstring& aString, + double& aTime) { + nsDependentSubstring original(aString); + uint32_t hh = 0; + double seconds = 0.0; + if (!ParseNPTHH(aString, hh)) { + return false; + } + + if (aString.Length() < 2 || aString[0] != ':') { + aString.Rebind(original, 0); + return false; + } + + aString.Rebind(aString, 1); + if (!ParseNPTMMSS(aString, seconds)) { + aString.Rebind(original, 0); + return false; + } + + aTime = hh * 3600 + seconds; + return true; +} + +bool nsMediaFragmentURIParser::ParseNPTHH(nsDependentSubstring& aString, + uint32_t& aHour) { + if (aString.Length() == 0) { + return false; + } + + uint32_t index = FirstNonDigit(aString, 0); + if (index == 0) { + return false; + } + + nsDependentSubstring n(aString, 0, index); + nsresult ec; + int32_t u = n.ToInteger(&ec); + if (NS_FAILED(ec)) { + return false; + } + + aString.Rebind(aString, index); + aHour = u; + return true; +} + +bool nsMediaFragmentURIParser::ParseNPTMM(nsDependentSubstring& aString, + uint32_t& aMinute) { + return ParseNPTSS(aString, aMinute); +} + +bool nsMediaFragmentURIParser::ParseNPTSS(nsDependentSubstring& aString, + uint32_t& aSecond) { + if (aString.Length() < 2) { + return false; + } + + if (IsDigit(aString[0]) && IsDigit(aString[1])) { + nsDependentSubstring n(aString, 0, 2); + nsresult ec; + int32_t u = n.ToInteger(&ec); + if (NS_FAILED(ec)) { + return false; + } + + aString.Rebind(aString, 2); + if (u >= 60) return false; + + aSecond = u; + return true; + } + + return false; +} + +static bool ParseInteger(nsDependentSubstring& aString, int32_t& aResult) { + uint32_t index = FirstNonDigit(aString, 0); + if (index == 0) { + return false; + } + + nsDependentSubstring n(aString, 0, index); + nsresult ec; + int32_t s = n.ToInteger(&ec); + if (NS_FAILED(ec)) { + return false; + } + + aString.Rebind(aString, index); + aResult = s; + return true; +} + +static bool ParseCommaSeparator(nsDependentSubstring& aString) { + if (aString.Length() > 1 && aString[0] == ',') { + aString.Rebind(aString, 1); + return true; + } + + return false; +} + +bool nsMediaFragmentURIParser::ParseXYWH(nsDependentSubstring aString) { + int32_t x, y, w, h; + ClipUnit clipUnit; + + // Determine units. + if (StringBeginsWith(aString, u"pixel:"_ns)) { + clipUnit = eClipUnit_Pixel; + aString.Rebind(aString, 6); + } else if (StringBeginsWith(aString, u"percent:"_ns)) { + clipUnit = eClipUnit_Percent; + aString.Rebind(aString, 8); + } else { + clipUnit = eClipUnit_Pixel; + } + + // Read and validate coordinates. + if (ParseInteger(aString, x) && x >= 0 && ParseCommaSeparator(aString) && + ParseInteger(aString, y) && y >= 0 && ParseCommaSeparator(aString) && + ParseInteger(aString, w) && w > 0 && ParseCommaSeparator(aString) && + ParseInteger(aString, h) && h > 0 && aString.Length() == 0) { + // Reject invalid percentage coordinates. + if (clipUnit == eClipUnit_Percent && (x + w > 100 || y + h > 100)) { + return false; + } + + mClip.emplace(x, y, w, h); + mClipUnit = clipUnit; + return true; + } + + return false; +} + +void nsMediaFragmentURIParser::Parse(nsACString& aRef) { + // Create an array of possibly-invalid media fragments. + nsTArray<std::pair<nsCString, nsCString> > fragments; + + for (const nsACString& nv : nsCCharSeparatedTokenizer(aRef, '&').ToRange()) { + int32_t index = nv.FindChar('='); + if (index >= 0) { + nsAutoCString name; + nsAutoCString value; + NS_UnescapeURL(StringHead(nv, index), esc_Ref | esc_AlwaysCopy, name); + NS_UnescapeURL(Substring(nv, index + 1, nv.Length()), + esc_Ref | esc_AlwaysCopy, value); + fragments.AppendElement(make_pair(name, value)); + } + } + + // Parse the media fragment values. + bool gotTemporal = false, gotSpatial = false; + for (int i = fragments.Length() - 1; i >= 0; --i) { + if (gotTemporal && gotSpatial) { + // We've got one of each possible type. No need to look at the rest. + break; + } else if (!gotTemporal && fragments[i].first.EqualsLiteral("t")) { + nsAutoString value = NS_ConvertUTF8toUTF16(fragments[i].second); + gotTemporal = ParseNPT(nsDependentSubstring(value, 0)); + } else if (!gotSpatial && fragments[i].first.EqualsLiteral("xywh")) { + nsAutoString value = NS_ConvertUTF8toUTF16(fragments[i].second); + gotSpatial = ParseXYWH(nsDependentSubstring(value, 0)); + } + } +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/nsMediaFragmentURIParser.h b/netwerk/base/nsMediaFragmentURIParser.h new file mode 100644 index 0000000000..4c277fead8 --- /dev/null +++ b/netwerk/base/nsMediaFragmentURIParser.h @@ -0,0 +1,99 @@ +/* -*- 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/. */ +#if !defined(nsMediaFragmentURIParser_h__) +# define nsMediaFragmentURIParser_h__ + +# include "mozilla/Maybe.h" +# include "nsStringFwd.h" +# include "nsRect.h" + +class nsIURI; + +// Class to handle parsing of a W3C media fragment URI as per +// spec at: http://www.w3.org/TR/media-frags/ +// Only the temporaral URI portion of the spec is implemented. +// To use: +// a) Construct an instance with the URI containing the fragment +// b) Check for the validity of the values you are interested in +// using e.g. HasStartTime(). +// c) If the values are valid, obtain them using e.g. GetStartTime(). + +namespace mozilla { +namespace net { + +enum ClipUnit { + eClipUnit_Pixel, + eClipUnit_Percent, +}; + +class nsMediaFragmentURIParser { + public: + // Create a parser with the provided URI. + explicit nsMediaFragmentURIParser(nsIURI* aURI); + + // Create a parser with the provided URI reference portion. + explicit nsMediaFragmentURIParser(nsCString& aRef); + + // True if a valid temporal media fragment indicated a start time. + bool HasStartTime() const { return mStart.isSome(); } + + // If a valid temporal media fragment indicated a start time, returns + // it in units of seconds. If not, defaults to 0. + double GetStartTime() const { return *mStart; } + + // True if a valid temporal media fragment indicated an end time. + bool HasEndTime() const { return mEnd.isSome(); } + + // If a valid temporal media fragment indicated an end time, returns + // it in units of seconds. If not, defaults to -1. + double GetEndTime() const { return *mEnd; } + + // True if a valid spatial media fragment indicated a clipping region. + bool HasClip() const { return mClip.isSome(); } + + // If a valid spatial media fragment indicated a clipping region, + // returns the region. If not, returns an empty region. The unit + // used depends on the value returned by GetClipUnit(). + nsIntRect GetClip() const { return *mClip; } + + // If a valid spatial media fragment indicated a clipping region, + // returns the unit used. + ClipUnit GetClipUnit() const { return mClipUnit; } + + private: + // Parse the URI ref provided, looking for media fragments. This is + // the top-level parser the invokes the others below. + void Parse(nsACString& aRef); + + // The following methods parse the fragment as per the media + // fragments specification. 'aString' contains the remaining + // fragment data to be parsed. The method returns true + // if the parse was successful and leaves the remaining unparsed + // data in 'aString'. If the parse fails then false is returned + // and 'aString' is left as it was when called. + bool ParseNPT(nsDependentSubstring aString); + bool ParseNPTTime(nsDependentSubstring& aString, double& aTime); + bool ParseNPTSec(nsDependentSubstring& aString, double& aSec); + bool ParseNPTFraction(nsDependentSubstring& aString, double& aFraction); + bool ParseNPTMMSS(nsDependentSubstring& aString, double& aTime); + bool ParseNPTHHMMSS(nsDependentSubstring& aString, double& aTime); + bool ParseNPTHH(nsDependentSubstring& aString, uint32_t& aHour); + bool ParseNPTMM(nsDependentSubstring& aString, uint32_t& aMinute); + bool ParseNPTSS(nsDependentSubstring& aString, uint32_t& aSecond); + bool ParseXYWH(nsDependentSubstring aString); + bool ParseMozResolution(nsDependentSubstring aString); + + // Media fragment information. + Maybe<double> mStart; + Maybe<double> mEnd; + Maybe<nsIntRect> mClip; + ClipUnit mClipUnit; +}; + +} // namespace net +} // namespace mozilla + +#endif diff --git a/netwerk/base/nsNetAddr.cpp b/netwerk/base/nsNetAddr.cpp new file mode 100644 index 0000000000..d0cbe69bae --- /dev/null +++ b/netwerk/base/nsNetAddr.cpp @@ -0,0 +1,138 @@ +/* vim: et ts=2 sw=2 tw=80 + */ +/* 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 "nsNetAddr.h" +#include "nsString.h" +#include "mozilla/net/DNS.h" + +using namespace mozilla::net; + +NS_IMPL_ISUPPORTS(nsNetAddr, nsINetAddr) + +NS_IMETHODIMP nsNetAddr::GetFamily(uint16_t* aFamily) { + switch (mAddr.raw.family) { + case AF_INET: + *aFamily = nsINetAddr::FAMILY_INET; + break; + case AF_INET6: + *aFamily = nsINetAddr::FAMILY_INET6; + break; +#if defined(XP_UNIX) + case AF_LOCAL: + *aFamily = nsINetAddr::FAMILY_LOCAL; + break; +#endif + default: + return NS_ERROR_UNEXPECTED; + } + + return NS_OK; +} + +NS_IMETHODIMP nsNetAddr::GetAddress(nsACString& aAddress) { + switch (mAddr.raw.family) { + /* PR_NetAddrToString can handle INET and INET6, but not LOCAL. */ + case AF_INET: + aAddress.SetLength(kIPv4CStrBufSize); + mAddr.ToStringBuffer(aAddress.BeginWriting(), kIPv4CStrBufSize); + aAddress.SetLength(strlen(aAddress.BeginReading())); + break; + case AF_INET6: + aAddress.SetLength(kIPv6CStrBufSize); + mAddr.ToStringBuffer(aAddress.BeginWriting(), kIPv6CStrBufSize); + aAddress.SetLength(strlen(aAddress.BeginReading())); + break; +#if defined(XP_UNIX) + case AF_LOCAL: + aAddress.Assign(mAddr.local.path); + break; +#endif + // PR_AF_LOCAL falls through to default when not XP_UNIX + default: + return NS_ERROR_UNEXPECTED; + } + + return NS_OK; +} + +NS_IMETHODIMP nsNetAddr::GetPort(uint16_t* aPort) { + switch (mAddr.raw.family) { + case AF_INET: + *aPort = ntohs(mAddr.inet.port); + break; + case AF_INET6: + *aPort = ntohs(mAddr.inet6.port); + break; +#if defined(XP_UNIX) + case AF_LOCAL: + // There is no port number for local / connections. + return NS_ERROR_NOT_AVAILABLE; +#endif + default: + return NS_ERROR_UNEXPECTED; + } + + return NS_OK; +} + +NS_IMETHODIMP nsNetAddr::GetFlow(uint32_t* aFlow) { + switch (mAddr.raw.family) { + case AF_INET6: + *aFlow = ntohl(mAddr.inet6.flowinfo); + break; + case AF_INET: +#if defined(XP_UNIX) + case AF_LOCAL: +#endif + // only for IPv6 + return NS_ERROR_NOT_AVAILABLE; + default: + return NS_ERROR_UNEXPECTED; + } + + return NS_OK; +} + +NS_IMETHODIMP nsNetAddr::GetScope(uint32_t* aScope) { + switch (mAddr.raw.family) { + case AF_INET6: + *aScope = ntohl(mAddr.inet6.scope_id); + break; + case AF_INET: +#if defined(XP_UNIX) + case AF_LOCAL: +#endif + // only for IPv6 + return NS_ERROR_NOT_AVAILABLE; + default: + return NS_ERROR_UNEXPECTED; + } + + return NS_OK; +} + +NS_IMETHODIMP nsNetAddr::GetIsV4Mapped(bool* aIsV4Mapped) { + switch (mAddr.raw.family) { + case AF_INET6: + *aIsV4Mapped = IPv6ADDR_IS_V4MAPPED(&mAddr.inet6.ip); + break; + case AF_INET: +#if defined(XP_UNIX) + case AF_LOCAL: +#endif + // only for IPv6 + return NS_ERROR_NOT_AVAILABLE; + default: + return NS_ERROR_UNEXPECTED; + } + + return NS_OK; +} + +NS_IMETHODIMP nsNetAddr::GetNetAddr(NetAddr* aResult) { + memcpy(aResult, &mAddr, sizeof(mAddr)); + return NS_OK; +} diff --git a/netwerk/base/nsNetAddr.h b/netwerk/base/nsNetAddr.h new file mode 100644 index 0000000000..49d43ccaee --- /dev/null +++ b/netwerk/base/nsNetAddr.h @@ -0,0 +1,30 @@ +/* vim: et ts=2 sw=2 tw=80 + */ +/* 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/. */ + +#ifndef nsNetAddr_h__ +#define nsNetAddr_h__ + +#include "nsINetAddr.h" +#include "mozilla/net/DNS.h" +#include "mozilla/Attributes.h" + +class nsNetAddr final : public nsINetAddr { + ~nsNetAddr() = default; + + public: + NS_DECL_ISUPPORTS + NS_DECL_NSINETADDR + + explicit nsNetAddr(const mozilla::net::NetAddr* addr) : mAddr(*addr) {} + + private: + mozilla::net::NetAddr mAddr; + + protected: + /* additional members */ +}; + +#endif // !nsNetAddr_h__ diff --git a/netwerk/base/nsNetSegmentUtils.h b/netwerk/base/nsNetSegmentUtils.h new file mode 100644 index 0000000000..a65defdb50 --- /dev/null +++ b/netwerk/base/nsNetSegmentUtils.h @@ -0,0 +1,20 @@ +/* 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/. */ + +#ifndef nsNetSegmentUtils_h__ +#define nsNetSegmentUtils_h__ + +#include "nsIOService.h" + +/** + * applies defaults to segment params in a consistent way. + */ +static inline void net_ResolveSegmentParams(uint32_t& segsize, + uint32_t& segcount) { + if (!segsize) segsize = mozilla::net::nsIOService::gDefaultSegmentSize; + + if (!segcount) segcount = mozilla::net::nsIOService::gDefaultSegmentCount; +} + +#endif // !nsNetSegmentUtils_h__ diff --git a/netwerk/base/nsNetUtil.cpp b/netwerk/base/nsNetUtil.cpp new file mode 100644 index 0000000000..1e50e5cebf --- /dev/null +++ b/netwerk/base/nsNetUtil.cpp @@ -0,0 +1,3268 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=4 sw=2 sts=2 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 "nsNetUtil.h" + +#include "mozilla/Atomics.h" +#include "mozilla/Encoding.h" +#include "mozilla/LoadContext.h" +#include "mozilla/LoadInfo.h" +#include "mozilla/BasePrincipal.h" +#include "mozilla/Monitor.h" +#include "mozilla/StaticPrefs_network.h" +#include "mozilla/StaticPrefs_privacy.h" +#include "mozilla/StoragePrincipalHelper.h" +#include "mozilla/TaskQueue.h" +#include "mozilla/Telemetry.h" +#include "nsBufferedStreams.h" +#include "nsCategoryCache.h" +#include "nsComponentManagerUtils.h" +#include "nsContentUtils.h" +#include "nsFileStreams.h" +#include "nsHashKeys.h" +#include "nsHttp.h" +#include "nsMimeTypes.h" +#include "nsIAuthPrompt.h" +#include "nsIAuthPrompt2.h" +#include "nsIAuthPromptAdapterFactory.h" +#include "nsIBufferedStreams.h" +#include "nsBufferedStreams.h" +#include "nsIChannelEventSink.h" +#include "nsIContentSniffer.h" +#include "mozilla/dom/Document.h" +#include "nsIDownloader.h" +#include "nsIFileProtocolHandler.h" +#include "nsIFileStreams.h" +#include "nsIFileURL.h" +#include "nsIIDNService.h" +#include "nsIInputStreamChannel.h" +#include "nsIInputStreamPump.h" +#include "nsIInterfaceRequestorUtils.h" +#include "nsILoadContext.h" +#include "nsIMIMEHeaderParam.h" +#include "nsINode.h" +#include "nsIObjectLoadingContent.h" +#include "nsIOfflineCacheUpdate.h" +#include "nsPersistentProperties.h" +#include "nsIPrivateBrowsingChannel.h" +#include "nsIPropertyBag2.h" +#include "nsIProtocolProxyService.h" +#include "mozilla/net/RedirectChannelRegistrar.h" +#include "nsRequestObserverProxy.h" +#include "nsISensitiveInfoHiddenURI.h" +#include "nsISimpleStreamListener.h" +#include "nsISocketProvider.h" +#include "nsIStandardURL.h" +#include "nsIStreamLoader.h" +#include "nsIIncrementalStreamLoader.h" +#include "nsStringStream.h" +#include "nsSyncStreamListener.h" +#include "nsITextToSubURI.h" +#include "nsIURIWithSpecialOrigin.h" +#include "nsIViewSourceChannel.h" +#include "nsInterfaceRequestorAgg.h" +#include "plstr.h" +#include "nsINestedURI.h" +#include "mozilla/dom/nsCSPUtils.h" +#include "mozilla/dom/nsHTTPSOnlyUtils.h" +#include "mozilla/dom/nsMixedContentBlocker.h" +#include "mozilla/dom/BlobURLProtocolHandler.h" +#include "mozilla/net/HttpBaseChannel.h" +#include "nsIScriptError.h" +#include "nsISiteSecurityService.h" +#include "nsHttpHandler.h" +#include "nsNSSComponent.h" +#include "nsIRedirectHistoryEntry.h" +#include "nsICertStorage.h" +#include "nsICertOverrideService.h" +#include "nsQueryObject.h" +#include "mozIThirdPartyUtil.h" +#include "../mime/nsMIMEHeaderParamImpl.h" +#include "nsStandardURL.h" +#include "DefaultURI.h" +#include "nsChromeProtocolHandler.h" +#include "nsJSProtocolHandler.h" +#include "nsDataHandler.h" +#include "mozilla/dom/BlobURLProtocolHandler.h" +#include "nsStreamUtils.h" +#include "nsSocketTransportService2.h" +#include "nsViewSourceHandler.h" +#include "nsJARURI.h" +#include "nsIconURI.h" +#include "nsAboutProtocolHandler.h" +#include "nsResProtocolHandler.h" +#include "mozilla/net/ExtensionProtocolHandler.h" +#include "mozilla/net/PageThumbProtocolHandler.h" +#include "mozilla/net/SFVService.h" +#include <limits> + +#if defined(MOZ_THUNDERBIRD) || defined(MOZ_SUITE) +# include "nsNewMailnewsURI.h" +#endif + +using namespace mozilla; +using namespace mozilla::net; +using mozilla::dom::BlobURLProtocolHandler; +using mozilla::dom::ClientInfo; +using mozilla::dom::PerformanceStorage; +using mozilla::dom::ServiceWorkerDescriptor; + +#define MAX_RECURSION_COUNT 50 + +already_AddRefed<nsIIOService> do_GetIOService(nsresult* error /* = 0 */) { + nsCOMPtr<nsIIOService> io = mozilla::services::GetIOService(); + if (error) *error = io ? NS_OK : NS_ERROR_FAILURE; + return io.forget(); +} + +nsresult NS_NewLocalFileInputStream(nsIInputStream** result, nsIFile* file, + int32_t ioFlags /* = -1 */, + int32_t perm /* = -1 */, + int32_t behaviorFlags /* = 0 */) { + nsresult rv; + nsCOMPtr<nsIFileInputStream> in = + do_CreateInstance(NS_LOCALFILEINPUTSTREAM_CONTRACTID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = in->Init(file, ioFlags, perm, behaviorFlags); + if (NS_SUCCEEDED(rv)) in.forget(result); + } + return rv; +} + +Result<nsCOMPtr<nsIInputStream>, nsresult> NS_NewLocalFileInputStream( + nsIFile* file, int32_t ioFlags /* = -1 */, int32_t perm /* = -1 */, + int32_t behaviorFlags /* = 0 */) { + nsCOMPtr<nsIInputStream> stream; + const nsresult rv = NS_NewLocalFileInputStream(getter_AddRefs(stream), file, + ioFlags, perm, behaviorFlags); + if (NS_SUCCEEDED(rv)) { + return stream; + } + return Err(rv); +} + +nsresult NS_NewLocalFileOutputStream(nsIOutputStream** result, nsIFile* file, + int32_t ioFlags /* = -1 */, + int32_t perm /* = -1 */, + int32_t behaviorFlags /* = 0 */) { + nsresult rv; + nsCOMPtr<nsIFileOutputStream> out = + do_CreateInstance(NS_LOCALFILEOUTPUTSTREAM_CONTRACTID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = out->Init(file, ioFlags, perm, behaviorFlags); + if (NS_SUCCEEDED(rv)) out.forget(result); + } + return rv; +} + +Result<nsCOMPtr<nsIOutputStream>, nsresult> NS_NewLocalFileOutputStream( + nsIFile* file, int32_t ioFlags /* = -1 */, int32_t perm /* = -1 */, + int32_t behaviorFlags /* = 0 */) { + nsCOMPtr<nsIOutputStream> stream; + const nsresult rv = NS_NewLocalFileOutputStream(getter_AddRefs(stream), file, + ioFlags, perm, behaviorFlags); + if (NS_SUCCEEDED(rv)) { + return stream; + } + return Err(rv); +} + +nsresult NS_NewLocalFileOutputStream(nsIOutputStream** result, + const mozilla::ipc::FileDescriptor& fd) { + nsCOMPtr<nsIFileOutputStream> out; + nsFileOutputStream::Create(nullptr, NS_GET_IID(nsIFileOutputStream), + getter_AddRefs(out)); + + nsresult rv = + static_cast<nsFileOutputStream*>(out.get())->InitWithFileDescriptor(fd); + if (NS_FAILED(rv)) { + return rv; + } + + out.forget(result); + return NS_OK; +} + +nsresult net_EnsureIOService(nsIIOService** ios, nsCOMPtr<nsIIOService>& grip) { + nsresult rv = NS_OK; + if (!*ios) { + grip = do_GetIOService(&rv); + *ios = grip; + } + return rv; +} + +nsresult NS_NewFileURI( + nsIURI** result, nsIFile* spec, + nsIIOService* + ioService /* = nullptr */) // pass in nsIIOService to optimize callers +{ + nsresult rv; + nsCOMPtr<nsIIOService> grip; + rv = net_EnsureIOService(&ioService, grip); + if (ioService) rv = ioService->NewFileURI(spec, result); + return rv; +} + +nsresult NS_GetURIWithNewRef(nsIURI* aInput, const nsACString& aRef, + nsIURI** aOutput) { + MOZ_DIAGNOSTIC_ASSERT(aRef.IsEmpty() || aRef[0] == '#'); + + if (NS_WARN_IF(!aInput || !aOutput)) { + return NS_ERROR_INVALID_ARG; + } + + bool hasRef; + nsresult rv = aInput->GetHasRef(&hasRef); + + nsAutoCString ref; + if (NS_SUCCEEDED(rv)) { + rv = aInput->GetRef(ref); + } + + // If the ref is already equal to the new ref, we do not need to do anything. + // Also, if the GetRef failed (it could return NS_ERROR_NOT_IMPLEMENTED) + // we can assume SetRef would fail as well, so returning the original + // URI is OK. + // + // Note that aRef contains the hash, but ref doesn't, so need to account for + // that in the equality check. + if (NS_FAILED(rv) || (!hasRef && aRef.IsEmpty()) || + (!aRef.IsEmpty() && hasRef && + Substring(aRef.Data() + 1, aRef.Length() - 1) == ref)) { + nsCOMPtr<nsIURI> uri = aInput; + uri.forget(aOutput); + return NS_OK; + } + + return NS_MutateURI(aInput).SetRef(aRef).Finalize(aOutput); +} + +nsresult NS_GetURIWithoutRef(nsIURI* aInput, nsIURI** aOutput) { + return NS_GetURIWithNewRef(aInput, ""_ns, aOutput); +} + +nsresult NS_NewChannelInternal( + nsIChannel** outChannel, nsIURI* aUri, nsILoadInfo* aLoadInfo, + PerformanceStorage* aPerformanceStorage /* = nullptr */, + nsILoadGroup* aLoadGroup /* = nullptr */, + nsIInterfaceRequestor* aCallbacks /* = nullptr */, + nsLoadFlags aLoadFlags /* = nsIRequest::LOAD_NORMAL */, + nsIIOService* aIoService /* = nullptr */) { + // NS_NewChannelInternal is mostly called for channel redirects. We should + // allow the creation of a channel even if the original channel did not have a + // loadinfo attached. + NS_ENSURE_ARG_POINTER(outChannel); + + nsCOMPtr<nsIIOService> grip; + nsresult rv = net_EnsureIOService(&aIoService, grip); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIChannel> channel; + rv = aIoService->NewChannelFromURIWithLoadInfo(aUri, aLoadInfo, + getter_AddRefs(channel)); + NS_ENSURE_SUCCESS(rv, rv); + + if (aLoadGroup) { + rv = channel->SetLoadGroup(aLoadGroup); + NS_ENSURE_SUCCESS(rv, rv); + } + + if (aCallbacks) { + rv = channel->SetNotificationCallbacks(aCallbacks); + NS_ENSURE_SUCCESS(rv, rv); + } + +#ifdef DEBUG + nsLoadFlags channelLoadFlags = 0; + channel->GetLoadFlags(&channelLoadFlags); + // Will be removed when we remove LOAD_REPLACE altogether + // This check is trying to catch protocol handlers that still + // try to set the LOAD_REPLACE flag. + MOZ_DIAGNOSTIC_ASSERT(!(channelLoadFlags & nsIChannel::LOAD_REPLACE)); +#endif + + if (aLoadFlags != nsIRequest::LOAD_NORMAL) { + rv = channel->SetLoadFlags(aLoadFlags); + NS_ENSURE_SUCCESS(rv, rv); + } + + if (aPerformanceStorage) { + nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo(); + loadInfo->SetPerformanceStorage(aPerformanceStorage); + } + + channel.forget(outChannel); + return NS_OK; +} + +namespace { + +void AssertLoadingPrincipalAndClientInfoMatch( + nsIPrincipal* aLoadingPrincipal, const ClientInfo& aLoadingClientInfo, + nsContentPolicyType aType) { +#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED + // Verify that the provided loading ClientInfo matches the loading + // principal. Unfortunately we can't just use nsIPrincipal::Equals() here + // because of some corner cases: + // + // 1. Worker debugger scripts want to use a system loading principal for + // worker scripts with a content principal. We exempt these from this + // check. + // 2. Null principals currently require exact object identity for + // nsIPrincipal::Equals() to return true. This doesn't work here because + // ClientInfo::GetPrincipal() uses PrincipalInfoToPrincipal() to allocate + // a new object. To work around this we compare the principal origin + // string itself. If bug 1431771 is fixed then we could switch to + // Equals(). + + // Allow worker debugger to load with a system principal. + if (aLoadingPrincipal->IsSystemPrincipal() && + (aType == nsIContentPolicy::TYPE_INTERNAL_WORKER || + aType == nsIContentPolicy::TYPE_INTERNAL_SHARED_WORKER || + aType == nsIContentPolicy::TYPE_INTERNAL_SERVICE_WORKER || + aType == nsIContentPolicy::TYPE_INTERNAL_WORKER_IMPORT_SCRIPTS)) { + return; + } + + // Perform a fast comparison for most principal checks. + auto clientPrincipalOrErr(aLoadingClientInfo.GetPrincipal()); + if (clientPrincipalOrErr.isOk()) { + nsCOMPtr<nsIPrincipal> clientPrincipal = clientPrincipalOrErr.unwrap(); + if (aLoadingPrincipal->Equals(clientPrincipal)) { + return; + } + // Fall back to a slower origin equality test to support null principals. + nsAutoCString loadingOrigin; + MOZ_ALWAYS_SUCCEEDS(aLoadingPrincipal->GetOrigin(loadingOrigin)); + + nsAutoCString clientOrigin; + MOZ_ALWAYS_SUCCEEDS(clientPrincipal->GetOrigin(clientOrigin)); + + MOZ_DIAGNOSTIC_ASSERT(loadingOrigin == clientOrigin); + } +#endif +} + +} // namespace + +nsresult NS_NewChannel(nsIChannel** outChannel, nsIURI* aUri, + nsIPrincipal* aLoadingPrincipal, + nsSecurityFlags aSecurityFlags, + nsContentPolicyType aContentPolicyType, + nsICookieJarSettings* aCookieJarSettings /* = nullptr */, + PerformanceStorage* aPerformanceStorage /* = nullptr */, + nsILoadGroup* aLoadGroup /* = nullptr */, + nsIInterfaceRequestor* aCallbacks /* = nullptr */, + nsLoadFlags aLoadFlags /* = nsIRequest::LOAD_NORMAL */, + nsIIOService* aIoService /* = nullptr */, + uint32_t aSandboxFlags /* = 0 */) { + return NS_NewChannelInternal( + outChannel, aUri, + nullptr, // aLoadingNode, + aLoadingPrincipal, + nullptr, // aTriggeringPrincipal + Maybe<ClientInfo>(), Maybe<ServiceWorkerDescriptor>(), aSecurityFlags, + aContentPolicyType, aCookieJarSettings, aPerformanceStorage, aLoadGroup, + aCallbacks, aLoadFlags, aIoService, aSandboxFlags); +} + +nsresult NS_NewChannel(nsIChannel** outChannel, nsIURI* aUri, + nsIPrincipal* aLoadingPrincipal, + const ClientInfo& aLoadingClientInfo, + const Maybe<ServiceWorkerDescriptor>& aController, + nsSecurityFlags aSecurityFlags, + nsContentPolicyType aContentPolicyType, + nsICookieJarSettings* aCookieJarSettings /* = nullptr */, + PerformanceStorage* aPerformanceStorage /* = nullptr */, + nsILoadGroup* aLoadGroup /* = nullptr */, + nsIInterfaceRequestor* aCallbacks /* = nullptr */, + nsLoadFlags aLoadFlags /* = nsIRequest::LOAD_NORMAL */, + nsIIOService* aIoService /* = nullptr */, + uint32_t aSandboxFlags /* = 0 */) { + AssertLoadingPrincipalAndClientInfoMatch( + aLoadingPrincipal, aLoadingClientInfo, aContentPolicyType); + + Maybe<ClientInfo> loadingClientInfo; + loadingClientInfo.emplace(aLoadingClientInfo); + + return NS_NewChannelInternal(outChannel, aUri, + nullptr, // aLoadingNode, + aLoadingPrincipal, + nullptr, // aTriggeringPrincipal + loadingClientInfo, aController, aSecurityFlags, + aContentPolicyType, aCookieJarSettings, + aPerformanceStorage, aLoadGroup, aCallbacks, + aLoadFlags, aIoService, aSandboxFlags); +} + +nsresult NS_NewChannelInternal( + nsIChannel** outChannel, nsIURI* aUri, nsINode* aLoadingNode, + nsIPrincipal* aLoadingPrincipal, nsIPrincipal* aTriggeringPrincipal, + const Maybe<ClientInfo>& aLoadingClientInfo, + const Maybe<ServiceWorkerDescriptor>& aController, + nsSecurityFlags aSecurityFlags, nsContentPolicyType aContentPolicyType, + nsICookieJarSettings* aCookieJarSettings /* = nullptr */, + PerformanceStorage* aPerformanceStorage /* = nullptr */, + nsILoadGroup* aLoadGroup /* = nullptr */, + nsIInterfaceRequestor* aCallbacks /* = nullptr */, + nsLoadFlags aLoadFlags /* = nsIRequest::LOAD_NORMAL */, + nsIIOService* aIoService /* = nullptr */, + uint32_t aSandboxFlags /* = 0 */) { + NS_ENSURE_ARG_POINTER(outChannel); + + nsCOMPtr<nsIIOService> grip; + nsresult rv = net_EnsureIOService(&aIoService, grip); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIChannel> channel; + rv = aIoService->NewChannelFromURIWithClientAndController( + aUri, aLoadingNode, aLoadingPrincipal, aTriggeringPrincipal, + aLoadingClientInfo, aController, aSecurityFlags, aContentPolicyType, + aSandboxFlags, getter_AddRefs(channel)); + if (NS_FAILED(rv)) { + return rv; + } + + if (aLoadGroup) { + rv = channel->SetLoadGroup(aLoadGroup); + NS_ENSURE_SUCCESS(rv, rv); + } + + if (aCallbacks) { + rv = channel->SetNotificationCallbacks(aCallbacks); + NS_ENSURE_SUCCESS(rv, rv); + } + +#ifdef DEBUG + nsLoadFlags channelLoadFlags = 0; + channel->GetLoadFlags(&channelLoadFlags); + // Will be removed when we remove LOAD_REPLACE altogether + // This check is trying to catch protocol handlers that still + // try to set the LOAD_REPLACE flag. + MOZ_DIAGNOSTIC_ASSERT(!(channelLoadFlags & nsIChannel::LOAD_REPLACE)); +#endif + + if (aLoadFlags != nsIRequest::LOAD_NORMAL) { + rv = channel->SetLoadFlags(aLoadFlags); + NS_ENSURE_SUCCESS(rv, rv); + } + + if (aPerformanceStorage || aCookieJarSettings) { + nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo(); + + if (aPerformanceStorage) { + loadInfo->SetPerformanceStorage(aPerformanceStorage); + } + + if (aCookieJarSettings) { + loadInfo->SetCookieJarSettings(aCookieJarSettings); + } + } + + channel.forget(outChannel); + return NS_OK; +} + +nsresult /*NS_NewChannelWithNodeAndTriggeringPrincipal */ +NS_NewChannelWithTriggeringPrincipal( + nsIChannel** outChannel, nsIURI* aUri, nsINode* aLoadingNode, + nsIPrincipal* aTriggeringPrincipal, nsSecurityFlags aSecurityFlags, + nsContentPolicyType aContentPolicyType, + PerformanceStorage* aPerformanceStorage /* = nullptr */, + nsILoadGroup* aLoadGroup /* = nullptr */, + nsIInterfaceRequestor* aCallbacks /* = nullptr */, + nsLoadFlags aLoadFlags /* = nsIRequest::LOAD_NORMAL */, + nsIIOService* aIoService /* = nullptr */) { + MOZ_ASSERT(aLoadingNode); + NS_ASSERTION(aTriggeringPrincipal, + "Can not create channel without a triggering Principal!"); + return NS_NewChannelInternal( + outChannel, aUri, aLoadingNode, aLoadingNode->NodePrincipal(), + aTriggeringPrincipal, Maybe<ClientInfo>(), + Maybe<ServiceWorkerDescriptor>(), aSecurityFlags, aContentPolicyType, + aLoadingNode->OwnerDoc()->CookieJarSettings(), aPerformanceStorage, + aLoadGroup, aCallbacks, aLoadFlags, aIoService); +} + +// See NS_NewChannelInternal for usage and argument description +nsresult NS_NewChannelWithTriggeringPrincipal( + nsIChannel** outChannel, nsIURI* aUri, nsIPrincipal* aLoadingPrincipal, + nsIPrincipal* aTriggeringPrincipal, nsSecurityFlags aSecurityFlags, + nsContentPolicyType aContentPolicyType, + nsICookieJarSettings* aCookieJarSettings /* = nullptr */, + PerformanceStorage* aPerformanceStorage /* = nullptr */, + nsILoadGroup* aLoadGroup /* = nullptr */, + nsIInterfaceRequestor* aCallbacks /* = nullptr */, + nsLoadFlags aLoadFlags /* = nsIRequest::LOAD_NORMAL */, + nsIIOService* aIoService /* = nullptr */) { + NS_ASSERTION(aLoadingPrincipal, + "Can not create channel without a loading Principal!"); + return NS_NewChannelInternal( + outChannel, aUri, + nullptr, // aLoadingNode + aLoadingPrincipal, aTriggeringPrincipal, Maybe<ClientInfo>(), + Maybe<ServiceWorkerDescriptor>(), aSecurityFlags, aContentPolicyType, + aCookieJarSettings, aPerformanceStorage, aLoadGroup, aCallbacks, + aLoadFlags, aIoService); +} + +// See NS_NewChannelInternal for usage and argument description +nsresult NS_NewChannelWithTriggeringPrincipal( + nsIChannel** outChannel, nsIURI* aUri, nsIPrincipal* aLoadingPrincipal, + nsIPrincipal* aTriggeringPrincipal, const ClientInfo& aLoadingClientInfo, + const Maybe<ServiceWorkerDescriptor>& aController, + nsSecurityFlags aSecurityFlags, nsContentPolicyType aContentPolicyType, + nsICookieJarSettings* aCookieJarSettings /* = nullptr */, + PerformanceStorage* aPerformanceStorage /* = nullptr */, + nsILoadGroup* aLoadGroup /* = nullptr */, + nsIInterfaceRequestor* aCallbacks /* = nullptr */, + nsLoadFlags aLoadFlags /* = nsIRequest::LOAD_NORMAL */, + nsIIOService* aIoService /* = nullptr */) { + AssertLoadingPrincipalAndClientInfoMatch( + aLoadingPrincipal, aLoadingClientInfo, aContentPolicyType); + + Maybe<ClientInfo> loadingClientInfo; + loadingClientInfo.emplace(aLoadingClientInfo); + + return NS_NewChannelInternal( + outChannel, aUri, + nullptr, // aLoadingNode + aLoadingPrincipal, aTriggeringPrincipal, loadingClientInfo, aController, + aSecurityFlags, aContentPolicyType, aCookieJarSettings, + aPerformanceStorage, aLoadGroup, aCallbacks, aLoadFlags, aIoService); +} + +nsresult NS_NewChannel(nsIChannel** outChannel, nsIURI* aUri, + nsINode* aLoadingNode, nsSecurityFlags aSecurityFlags, + nsContentPolicyType aContentPolicyType, + PerformanceStorage* aPerformanceStorage /* = nullptr */, + nsILoadGroup* aLoadGroup /* = nullptr */, + nsIInterfaceRequestor* aCallbacks /* = nullptr */, + nsLoadFlags aLoadFlags /* = nsIRequest::LOAD_NORMAL */, + nsIIOService* aIoService /* = nullptr */, + uint32_t aSandboxFlags /* = 0 */) { + NS_ASSERTION(aLoadingNode, "Can not create channel without a loading Node!"); + return NS_NewChannelInternal( + outChannel, aUri, aLoadingNode, aLoadingNode->NodePrincipal(), + nullptr, // aTriggeringPrincipal + Maybe<ClientInfo>(), Maybe<ServiceWorkerDescriptor>(), aSecurityFlags, + aContentPolicyType, aLoadingNode->OwnerDoc()->CookieJarSettings(), + aPerformanceStorage, aLoadGroup, aCallbacks, aLoadFlags, aIoService, + aSandboxFlags); +} + +nsresult NS_GetIsDocumentChannel(nsIChannel* aChannel, bool* aIsDocument) { + // Check if this channel is going to be used to create a document. If it has + // LOAD_DOCUMENT_URI set it is trivially creating a document. If + // LOAD_HTML_OBJECT_DATA is set it may or may not be used to create a + // document, depending on its MIME type. + + if (!aChannel || !aIsDocument) { + return NS_ERROR_NULL_POINTER; + } + *aIsDocument = false; + nsLoadFlags loadFlags; + nsresult rv = aChannel->GetLoadFlags(&loadFlags); + if (NS_FAILED(rv)) { + return rv; + } + if (loadFlags & nsIChannel::LOAD_DOCUMENT_URI) { + *aIsDocument = true; + return NS_OK; + } + if (!(loadFlags & nsIRequest::LOAD_HTML_OBJECT_DATA)) { + *aIsDocument = false; + return NS_OK; + } + nsAutoCString mimeType; + rv = aChannel->GetContentType(mimeType); + if (NS_FAILED(rv)) { + return rv; + } + if (nsContentUtils::HtmlObjectContentTypeForMIMEType( + mimeType, false, nullptr) == nsIObjectLoadingContent::TYPE_DOCUMENT) { + *aIsDocument = true; + return NS_OK; + } + *aIsDocument = false; + return NS_OK; +} + +nsresult NS_MakeAbsoluteURI(nsACString& result, const nsACString& spec, + nsIURI* baseURI) { + nsresult rv; + if (!baseURI) { + NS_WARNING("It doesn't make sense to not supply a base URI"); + result = spec; + rv = NS_OK; + } else if (spec.IsEmpty()) + rv = baseURI->GetSpec(result); + else + rv = baseURI->Resolve(spec, result); + return rv; +} + +nsresult NS_MakeAbsoluteURI(char** result, const char* spec, nsIURI* baseURI) { + nsresult rv; + nsAutoCString resultBuf; + rv = NS_MakeAbsoluteURI(resultBuf, nsDependentCString(spec), baseURI); + if (NS_SUCCEEDED(rv)) { + *result = ToNewCString(resultBuf, mozilla::fallible); + if (!*result) rv = NS_ERROR_OUT_OF_MEMORY; + } + return rv; +} + +nsresult NS_MakeAbsoluteURI(nsAString& result, const nsAString& spec, + nsIURI* baseURI) { + nsresult rv; + if (!baseURI) { + NS_WARNING("It doesn't make sense to not supply a base URI"); + result = spec; + rv = NS_OK; + } else { + nsAutoCString resultBuf; + if (spec.IsEmpty()) + rv = baseURI->GetSpec(resultBuf); + else + rv = baseURI->Resolve(NS_ConvertUTF16toUTF8(spec), resultBuf); + if (NS_SUCCEEDED(rv)) CopyUTF8toUTF16(resultBuf, result); + } + return rv; +} + +int32_t NS_GetDefaultPort(const char* scheme, + nsIIOService* ioService /* = nullptr */) { + nsresult rv; + + // Getting the default port through the protocol handler has a lot of XPCOM + // overhead involved. We optimize the protocols that matter for Web pages + // (HTTP and HTTPS) by hardcoding their default ports here. + if (strncmp(scheme, "http", 4) == 0) { + if (scheme[4] == 's' && scheme[5] == '\0') { + return 443; + } + if (scheme[4] == '\0') { + return 80; + } + } + + nsCOMPtr<nsIIOService> grip; + net_EnsureIOService(&ioService, grip); + if (!ioService) return -1; + + nsCOMPtr<nsIProtocolHandler> handler; + rv = ioService->GetProtocolHandler(scheme, getter_AddRefs(handler)); + if (NS_FAILED(rv)) return -1; + int32_t port; + rv = handler->GetDefaultPort(&port); + return NS_SUCCEEDED(rv) ? port : -1; +} + +/** + * This function is a helper function to apply the ToAscii conversion + * to a string + */ +bool NS_StringToACE(const nsACString& idn, nsACString& result) { + nsCOMPtr<nsIIDNService> idnSrv = do_GetService(NS_IDNSERVICE_CONTRACTID); + if (!idnSrv) return false; + nsresult rv = idnSrv->ConvertUTF8toACE(idn, result); + if (NS_FAILED(rv)) return false; + + return true; +} + +int32_t NS_GetRealPort(nsIURI* aURI) { + int32_t port; + nsresult rv = aURI->GetPort(&port); + if (NS_FAILED(rv)) return -1; + + if (port != -1) return port; // explicitly specified + + // Otherwise, we have to get the default port from the protocol handler + + // Need the scheme first + nsAutoCString scheme; + rv = aURI->GetScheme(scheme); + if (NS_FAILED(rv)) return -1; + + return NS_GetDefaultPort(scheme.get()); +} + +nsresult NS_NewInputStreamChannelInternal( + nsIChannel** outChannel, nsIURI* aUri, + already_AddRefed<nsIInputStream> aStream, const nsACString& aContentType, + const nsACString& aContentCharset, nsILoadInfo* aLoadInfo) { + nsresult rv; + nsCOMPtr<nsIInputStreamChannel> isc = + do_CreateInstance(NS_INPUTSTREAMCHANNEL_CONTRACTID, &rv); + NS_ENSURE_SUCCESS(rv, rv); + rv = isc->SetURI(aUri); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIInputStream> stream = std::move(aStream); + rv = isc->SetContentStream(stream); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIChannel> channel = do_QueryInterface(isc, &rv); + NS_ENSURE_SUCCESS(rv, rv); + + if (!aContentType.IsEmpty()) { + rv = channel->SetContentType(aContentType); + NS_ENSURE_SUCCESS(rv, rv); + } + + if (!aContentCharset.IsEmpty()) { + rv = channel->SetContentCharset(aContentCharset); + NS_ENSURE_SUCCESS(rv, rv); + } + + MOZ_ASSERT(aLoadInfo, "need a loadinfo to create a inputstreamchannel"); + channel->SetLoadInfo(aLoadInfo); + + // If we're sandboxed, make sure to clear any owner the channel + // might already have. + if (aLoadInfo && aLoadInfo->GetLoadingSandboxed()) { + channel->SetOwner(nullptr); + } + + channel.forget(outChannel); + return NS_OK; +} + +nsresult NS_NewInputStreamChannelInternal( + nsIChannel** outChannel, nsIURI* aUri, + already_AddRefed<nsIInputStream> aStream, const nsACString& aContentType, + const nsACString& aContentCharset, nsINode* aLoadingNode, + nsIPrincipal* aLoadingPrincipal, nsIPrincipal* aTriggeringPrincipal, + nsSecurityFlags aSecurityFlags, nsContentPolicyType aContentPolicyType) { + nsCOMPtr<nsILoadInfo> loadInfo = new mozilla::net::LoadInfo( + aLoadingPrincipal, aTriggeringPrincipal, aLoadingNode, aSecurityFlags, + aContentPolicyType); + if (!loadInfo) { + return NS_ERROR_UNEXPECTED; + } + + nsCOMPtr<nsIInputStream> stream = std::move(aStream); + + return NS_NewInputStreamChannelInternal(outChannel, aUri, stream.forget(), + aContentType, aContentCharset, + loadInfo); +} + +nsresult NS_NewInputStreamChannel( + nsIChannel** outChannel, nsIURI* aUri, + already_AddRefed<nsIInputStream> aStream, nsIPrincipal* aLoadingPrincipal, + nsSecurityFlags aSecurityFlags, nsContentPolicyType aContentPolicyType, + const nsACString& aContentType /* = ""_ns */, + const nsACString& aContentCharset /* = ""_ns */) { + nsCOMPtr<nsIInputStream> stream = aStream; + return NS_NewInputStreamChannelInternal(outChannel, aUri, stream.forget(), + aContentType, aContentCharset, + nullptr, // aLoadingNode + aLoadingPrincipal, + nullptr, // aTriggeringPrincipal + aSecurityFlags, aContentPolicyType); +} + +nsresult NS_NewInputStreamChannelInternal(nsIChannel** outChannel, nsIURI* aUri, + const nsAString& aData, + const nsACString& aContentType, + nsILoadInfo* aLoadInfo, + bool aIsSrcdocChannel /* = false */) { + nsresult rv; + nsCOMPtr<nsIStringInputStream> stream; + stream = do_CreateInstance(NS_STRINGINPUTSTREAM_CONTRACTID, &rv); + NS_ENSURE_SUCCESS(rv, rv); + + uint32_t len; + char* utf8Bytes = ToNewUTF8String(aData, &len); + rv = stream->AdoptData(utf8Bytes, len); + + nsCOMPtr<nsIChannel> channel; + rv = NS_NewInputStreamChannelInternal(getter_AddRefs(channel), aUri, + stream.forget(), aContentType, + "UTF-8"_ns, aLoadInfo); + + NS_ENSURE_SUCCESS(rv, rv); + + if (aIsSrcdocChannel) { + nsCOMPtr<nsIInputStreamChannel> inStrmChan = do_QueryInterface(channel); + NS_ENSURE_TRUE(inStrmChan, NS_ERROR_FAILURE); + inStrmChan->SetSrcdocData(aData); + } + channel.forget(outChannel); + return NS_OK; +} + +nsresult NS_NewInputStreamChannelInternal( + nsIChannel** outChannel, nsIURI* aUri, const nsAString& aData, + const nsACString& aContentType, nsINode* aLoadingNode, + nsIPrincipal* aLoadingPrincipal, nsIPrincipal* aTriggeringPrincipal, + nsSecurityFlags aSecurityFlags, nsContentPolicyType aContentPolicyType, + bool aIsSrcdocChannel /* = false */) { + nsCOMPtr<nsILoadInfo> loadInfo = new mozilla::net::LoadInfo( + aLoadingPrincipal, aTriggeringPrincipal, aLoadingNode, aSecurityFlags, + aContentPolicyType); + return NS_NewInputStreamChannelInternal(outChannel, aUri, aData, aContentType, + loadInfo, aIsSrcdocChannel); +} + +nsresult NS_NewInputStreamChannel(nsIChannel** outChannel, nsIURI* aUri, + const nsAString& aData, + const nsACString& aContentType, + nsIPrincipal* aLoadingPrincipal, + nsSecurityFlags aSecurityFlags, + nsContentPolicyType aContentPolicyType, + bool aIsSrcdocChannel /* = false */) { + return NS_NewInputStreamChannelInternal(outChannel, aUri, aData, aContentType, + nullptr, // aLoadingNode + aLoadingPrincipal, + nullptr, // aTriggeringPrincipal + aSecurityFlags, aContentPolicyType, + aIsSrcdocChannel); +} + +nsresult NS_NewInputStreamPump( + nsIInputStreamPump** aResult, already_AddRefed<nsIInputStream> aStream, + uint32_t aSegsize /* = 0 */, uint32_t aSegcount /* = 0 */, + bool aCloseWhenDone /* = false */, + nsIEventTarget* aMainThreadTarget /* = nullptr */) { + nsCOMPtr<nsIInputStream> stream = std::move(aStream); + + nsresult rv; + nsCOMPtr<nsIInputStreamPump> pump = + do_CreateInstance(NS_INPUTSTREAMPUMP_CONTRACTID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = pump->Init(stream, aSegsize, aSegcount, aCloseWhenDone, + aMainThreadTarget); + if (NS_SUCCEEDED(rv)) { + *aResult = nullptr; + pump.swap(*aResult); + } + } + return rv; +} + +nsresult NS_NewLoadGroup(nsILoadGroup** result, nsIRequestObserver* obs) { + nsresult rv; + nsCOMPtr<nsILoadGroup> group = + do_CreateInstance(NS_LOADGROUP_CONTRACTID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = group->SetGroupObserver(obs); + if (NS_SUCCEEDED(rv)) { + *result = nullptr; + group.swap(*result); + } + } + return rv; +} + +bool NS_IsReasonableHTTPHeaderValue(const nsACString& aValue) { + return mozilla::net::nsHttp::IsReasonableHeaderValue(aValue); +} + +bool NS_IsValidHTTPToken(const nsACString& aToken) { + return mozilla::net::nsHttp::IsValidToken(aToken); +} + +void NS_TrimHTTPWhitespace(const nsACString& aSource, nsACString& aDest) { + mozilla::net::nsHttp::TrimHTTPWhitespace(aSource, aDest); +} + +nsresult NS_NewLoadGroup(nsILoadGroup** aResult, nsIPrincipal* aPrincipal) { + using mozilla::LoadContext; + nsresult rv; + + nsCOMPtr<nsILoadGroup> group = + do_CreateInstance(NS_LOADGROUP_CONTRACTID, &rv); + NS_ENSURE_SUCCESS(rv, rv); + + RefPtr<LoadContext> loadContext = new LoadContext(aPrincipal); + rv = group->SetNotificationCallbacks(loadContext); + NS_ENSURE_SUCCESS(rv, rv); + + group.forget(aResult); + return rv; +} + +bool NS_LoadGroupMatchesPrincipal(nsILoadGroup* aLoadGroup, + nsIPrincipal* aPrincipal) { + if (!aPrincipal) { + return false; + } + + // If this is a null principal then the load group doesn't really matter. + // The principal will not be allowed to perform any actions that actually + // use the load group. Unconditionally treat null principals as a match. + if (aPrincipal->GetIsNullPrincipal()) { + return true; + } + + if (!aLoadGroup) { + return false; + } + + nsCOMPtr<nsILoadContext> loadContext; + NS_QueryNotificationCallbacks(nullptr, aLoadGroup, NS_GET_IID(nsILoadContext), + getter_AddRefs(loadContext)); + NS_ENSURE_TRUE(loadContext, false); + + return true; +} + +nsresult NS_NewDownloader(nsIStreamListener** result, + nsIDownloadObserver* observer, + nsIFile* downloadLocation /* = nullptr */) { + nsresult rv; + nsCOMPtr<nsIDownloader> downloader = + do_CreateInstance(NS_DOWNLOADER_CONTRACTID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = downloader->Init(observer, downloadLocation); + if (NS_SUCCEEDED(rv)) { + downloader.forget(result); + } + } + return rv; +} + +nsresult NS_NewIncrementalStreamLoader( + nsIIncrementalStreamLoader** result, + nsIIncrementalStreamLoaderObserver* observer) { + nsresult rv; + nsCOMPtr<nsIIncrementalStreamLoader> loader = + do_CreateInstance(NS_INCREMENTALSTREAMLOADER_CONTRACTID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = loader->Init(observer); + if (NS_SUCCEEDED(rv)) { + *result = nullptr; + loader.swap(*result); + } + } + return rv; +} + +nsresult NS_NewStreamLoader( + nsIStreamLoader** result, nsIStreamLoaderObserver* observer, + nsIRequestObserver* requestObserver /* = nullptr */) { + nsresult rv; + nsCOMPtr<nsIStreamLoader> loader = + do_CreateInstance(NS_STREAMLOADER_CONTRACTID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = loader->Init(observer, requestObserver); + if (NS_SUCCEEDED(rv)) { + *result = nullptr; + loader.swap(*result); + } + } + return rv; +} + +nsresult NS_NewStreamLoaderInternal( + nsIStreamLoader** outStream, nsIURI* aUri, + nsIStreamLoaderObserver* aObserver, nsINode* aLoadingNode, + nsIPrincipal* aLoadingPrincipal, nsSecurityFlags aSecurityFlags, + nsContentPolicyType aContentPolicyType, + nsILoadGroup* aLoadGroup /* = nullptr */, + nsIInterfaceRequestor* aCallbacks /* = nullptr */, + nsLoadFlags aLoadFlags /* = nsIRequest::LOAD_NORMAL */) { + nsCOMPtr<nsIChannel> channel; + nsresult rv = NS_NewChannelInternal( + getter_AddRefs(channel), aUri, aLoadingNode, aLoadingPrincipal, + nullptr, // aTriggeringPrincipal + Maybe<ClientInfo>(), Maybe<ServiceWorkerDescriptor>(), aSecurityFlags, + aContentPolicyType, + nullptr, // nsICookieJarSettings + nullptr, // PerformanceStorage + aLoadGroup, aCallbacks, aLoadFlags); + + NS_ENSURE_SUCCESS(rv, rv); + rv = NS_NewStreamLoader(outStream, aObserver); + NS_ENSURE_SUCCESS(rv, rv); + return channel->AsyncOpen(*outStream); +} + +nsresult NS_NewStreamLoader( + nsIStreamLoader** outStream, nsIURI* aUri, + nsIStreamLoaderObserver* aObserver, nsINode* aLoadingNode, + nsSecurityFlags aSecurityFlags, nsContentPolicyType aContentPolicyType, + nsILoadGroup* aLoadGroup /* = nullptr */, + nsIInterfaceRequestor* aCallbacks /* = nullptr */, + nsLoadFlags aLoadFlags /* = nsIRequest::LOAD_NORMAL */) { + NS_ASSERTION(aLoadingNode, + "Can not create stream loader without a loading Node!"); + return NS_NewStreamLoaderInternal( + outStream, aUri, aObserver, aLoadingNode, aLoadingNode->NodePrincipal(), + aSecurityFlags, aContentPolicyType, aLoadGroup, aCallbacks, aLoadFlags); +} + +nsresult NS_NewStreamLoader( + nsIStreamLoader** outStream, nsIURI* aUri, + nsIStreamLoaderObserver* aObserver, nsIPrincipal* aLoadingPrincipal, + nsSecurityFlags aSecurityFlags, nsContentPolicyType aContentPolicyType, + nsILoadGroup* aLoadGroup /* = nullptr */, + nsIInterfaceRequestor* aCallbacks /* = nullptr */, + nsLoadFlags aLoadFlags /* = nsIRequest::LOAD_NORMAL */) { + return NS_NewStreamLoaderInternal(outStream, aUri, aObserver, + nullptr, // aLoadingNode + aLoadingPrincipal, aSecurityFlags, + aContentPolicyType, aLoadGroup, aCallbacks, + aLoadFlags); +} + +nsresult NS_NewSyncStreamListener(nsIStreamListener** result, + nsIInputStream** stream) { + nsCOMPtr<nsISyncStreamListener> listener = nsSyncStreamListener::Create(); + if (listener) { + nsresult rv = listener->GetInputStream(stream); + if (NS_SUCCEEDED(rv)) { + listener.forget(result); + } + return rv; + } + return NS_ERROR_FAILURE; +} + +nsresult NS_ImplementChannelOpen(nsIChannel* channel, nsIInputStream** result) { + nsCOMPtr<nsIStreamListener> listener; + nsCOMPtr<nsIInputStream> stream; + nsresult rv = NS_NewSyncStreamListener(getter_AddRefs(listener), + getter_AddRefs(stream)); + NS_ENSURE_SUCCESS(rv, rv); + + rv = NS_MaybeOpenChannelUsingAsyncOpen(channel, listener); + NS_ENSURE_SUCCESS(rv, rv); + + uint64_t n; + // block until the initial response is received or an error occurs. + rv = stream->Available(&n); + NS_ENSURE_SUCCESS(rv, rv); + + *result = nullptr; + stream.swap(*result); + + return NS_OK; +} + +nsresult NS_NewRequestObserverProxy(nsIRequestObserver** result, + nsIRequestObserver* observer, + nsISupports* context) { + nsCOMPtr<nsIRequestObserverProxy> proxy = new nsRequestObserverProxy(); + nsresult rv = proxy->Init(observer, context); + if (NS_SUCCEEDED(rv)) { + proxy.forget(result); + } + return rv; +} + +nsresult NS_NewSimpleStreamListener( + nsIStreamListener** result, nsIOutputStream* sink, + nsIRequestObserver* observer /* = nullptr */) { + nsresult rv; + nsCOMPtr<nsISimpleStreamListener> listener = + do_CreateInstance(NS_SIMPLESTREAMLISTENER_CONTRACTID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = listener->Init(sink, observer); + if (NS_SUCCEEDED(rv)) { + listener.forget(result); + } + } + return rv; +} + +nsresult NS_CheckPortSafety(int32_t port, const char* scheme, + nsIIOService* ioService /* = nullptr */) { + nsresult rv; + nsCOMPtr<nsIIOService> grip; + rv = net_EnsureIOService(&ioService, grip); + if (ioService) { + bool allow; + rv = ioService->AllowPort(port, scheme, &allow); + if (NS_SUCCEEDED(rv) && !allow) { + NS_WARNING("port blocked"); + rv = NS_ERROR_PORT_ACCESS_NOT_ALLOWED; + } + } + return rv; +} + +nsresult NS_CheckPortSafety(nsIURI* uri) { + int32_t port; + nsresult rv = uri->GetPort(&port); + if (NS_FAILED(rv) || port == -1) // port undefined or default-valued + return NS_OK; + nsAutoCString scheme; + uri->GetScheme(scheme); + return NS_CheckPortSafety(port, scheme.get()); +} + +nsresult NS_NewProxyInfo(const nsACString& type, const nsACString& host, + int32_t port, uint32_t flags, nsIProxyInfo** result) { + nsresult rv; + nsCOMPtr<nsIProtocolProxyService> pps = + do_GetService(NS_PROTOCOLPROXYSERVICE_CONTRACTID, &rv); + if (NS_SUCCEEDED(rv)) + rv = pps->NewProxyInfo(type, host, port, ""_ns, ""_ns, flags, UINT32_MAX, + nullptr, result); + return rv; +} + +nsresult NS_GetFileProtocolHandler(nsIFileProtocolHandler** result, + nsIIOService* ioService /* = nullptr */) { + nsresult rv; + nsCOMPtr<nsIIOService> grip; + rv = net_EnsureIOService(&ioService, grip); + if (ioService) { + nsCOMPtr<nsIProtocolHandler> handler; + rv = ioService->GetProtocolHandler("file", getter_AddRefs(handler)); + if (NS_SUCCEEDED(rv)) rv = CallQueryInterface(handler, result); + } + return rv; +} + +nsresult NS_GetFileFromURLSpec(const nsACString& inURL, nsIFile** result, + nsIIOService* ioService /* = nullptr */) { + nsresult rv; + nsCOMPtr<nsIFileProtocolHandler> fileHandler; + rv = NS_GetFileProtocolHandler(getter_AddRefs(fileHandler), ioService); + if (NS_SUCCEEDED(rv)) rv = fileHandler->GetFileFromURLSpec(inURL, result); + return rv; +} + +nsresult NS_GetURLSpecFromFile(nsIFile* file, nsACString& url, + nsIIOService* ioService /* = nullptr */) { + nsresult rv; + nsCOMPtr<nsIFileProtocolHandler> fileHandler; + rv = NS_GetFileProtocolHandler(getter_AddRefs(fileHandler), ioService); + if (NS_SUCCEEDED(rv)) rv = fileHandler->GetURLSpecFromFile(file, url); + return rv; +} + +nsresult NS_GetURLSpecFromActualFile(nsIFile* file, nsACString& url, + nsIIOService* ioService /* = nullptr */) { + nsresult rv; + nsCOMPtr<nsIFileProtocolHandler> fileHandler; + rv = NS_GetFileProtocolHandler(getter_AddRefs(fileHandler), ioService); + if (NS_SUCCEEDED(rv)) rv = fileHandler->GetURLSpecFromActualFile(file, url); + return rv; +} + +nsresult NS_GetURLSpecFromDir(nsIFile* file, nsACString& url, + nsIIOService* ioService /* = nullptr */) { + nsresult rv; + nsCOMPtr<nsIFileProtocolHandler> fileHandler; + rv = NS_GetFileProtocolHandler(getter_AddRefs(fileHandler), ioService); + if (NS_SUCCEEDED(rv)) rv = fileHandler->GetURLSpecFromDir(file, url); + return rv; +} + +void NS_GetReferrerFromChannel(nsIChannel* channel, nsIURI** referrer) { + *referrer = nullptr; + + nsCOMPtr<nsIPropertyBag2> props(do_QueryInterface(channel)); + if (props) { + // We have to check for a property on a property bag because the + // referrer may be empty for security reasons (for example, when loading + // an http page with an https referrer). + nsresult rv = props->GetPropertyAsInterface( + u"docshell.internalReferrer"_ns, NS_GET_IID(nsIURI), + reinterpret_cast<void**>(referrer)); + if (NS_SUCCEEDED(rv)) { + return; + } + } + + // if that didn't work, we can still try to get the referrer from the + // nsIHttpChannel (if we can QI to it) + nsCOMPtr<nsIHttpChannel> chan(do_QueryInterface(channel)); + if (!chan) { + return; + } + + nsCOMPtr<nsIReferrerInfo> referrerInfo = chan->GetReferrerInfo(); + if (!referrerInfo) { + return; + } + + referrerInfo->GetOriginalReferrer(referrer); +} + +already_AddRefed<nsINetUtil> do_GetNetUtil(nsresult* error /* = 0 */) { + nsCOMPtr<nsIIOService> io = mozilla::services::GetIOService(); + nsCOMPtr<nsINetUtil> util; + if (io) util = do_QueryInterface(io); + + if (error) *error = !!util ? NS_OK : NS_ERROR_FAILURE; + return util.forget(); +} + +nsresult NS_ParseRequestContentType(const nsACString& rawContentType, + nsCString& contentType, + nsCString& contentCharset) { + // contentCharset is left untouched if not present in rawContentType + nsresult rv; + nsCOMPtr<nsINetUtil> util = do_GetNetUtil(&rv); + NS_ENSURE_SUCCESS(rv, rv); + nsCString charset; + bool hadCharset; + rv = util->ParseRequestContentType(rawContentType, charset, &hadCharset, + contentType); + if (NS_SUCCEEDED(rv) && hadCharset) contentCharset = charset; + return rv; +} + +nsresult NS_ParseResponseContentType(const nsACString& rawContentType, + nsCString& contentType, + nsCString& contentCharset) { + // contentCharset is left untouched if not present in rawContentType + nsresult rv; + nsCOMPtr<nsINetUtil> util = do_GetNetUtil(&rv); + NS_ENSURE_SUCCESS(rv, rv); + nsCString charset; + bool hadCharset; + rv = util->ParseResponseContentType(rawContentType, charset, &hadCharset, + contentType); + if (NS_SUCCEEDED(rv) && hadCharset) contentCharset = charset; + return rv; +} + +nsresult NS_ExtractCharsetFromContentType(const nsACString& rawContentType, + nsCString& contentCharset, + bool* hadCharset, + int32_t* charsetStart, + int32_t* charsetEnd) { + // contentCharset is left untouched if not present in rawContentType + nsresult rv; + nsCOMPtr<nsINetUtil> util = do_GetNetUtil(&rv); + NS_ENSURE_SUCCESS(rv, rv); + + return util->ExtractCharsetFromContentType( + rawContentType, contentCharset, charsetStart, charsetEnd, hadCharset); +} + +nsresult NS_NewAtomicFileOutputStream(nsIOutputStream** result, nsIFile* file, + int32_t ioFlags /* = -1 */, + int32_t perm /* = -1 */, + int32_t behaviorFlags /* = 0 */) { + nsresult rv; + nsCOMPtr<nsIFileOutputStream> out = + do_CreateInstance(NS_ATOMICLOCALFILEOUTPUTSTREAM_CONTRACTID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = out->Init(file, ioFlags, perm, behaviorFlags); + if (NS_SUCCEEDED(rv)) out.forget(result); + } + return rv; +} + +nsresult NS_NewSafeLocalFileOutputStream(nsIOutputStream** result, + nsIFile* file, + int32_t ioFlags /* = -1 */, + int32_t perm /* = -1 */, + int32_t behaviorFlags /* = 0 */) { + nsresult rv; + nsCOMPtr<nsIFileOutputStream> out = + do_CreateInstance(NS_SAFELOCALFILEOUTPUTSTREAM_CONTRACTID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = out->Init(file, ioFlags, perm, behaviorFlags); + if (NS_SUCCEEDED(rv)) out.forget(result); + } + return rv; +} + +nsresult NS_NewLocalFileStream(nsIFileStream** result, nsIFile* file, + int32_t ioFlags /* = -1 */, + int32_t perm /* = -1 */, + int32_t behaviorFlags /* = 0 */) { + nsCOMPtr<nsIFileStream> stream = new nsFileStream(); + nsresult rv = stream->Init(file, ioFlags, perm, behaviorFlags); + if (NS_SUCCEEDED(rv)) { + stream.forget(result); + } + return rv; +} + +mozilla::Result<nsCOMPtr<nsIFileStream>, nsresult> NS_NewLocalFileStream( + nsIFile* file, int32_t ioFlags /* = -1 */, int32_t perm /* = -1 */, + int32_t behaviorFlags /* = 0 */) { + nsCOMPtr<nsIFileStream> stream; + const nsresult rv = NS_NewLocalFileStream(getter_AddRefs(stream), file, + ioFlags, perm, behaviorFlags); + if (NS_SUCCEEDED(rv)) { + return stream; + } + return Err(rv); +} + +nsresult NS_NewBufferedOutputStream( + nsIOutputStream** aResult, already_AddRefed<nsIOutputStream> aOutputStream, + uint32_t aBufferSize) { + nsCOMPtr<nsIOutputStream> outputStream = std::move(aOutputStream); + + nsresult rv; + nsCOMPtr<nsIBufferedOutputStream> out = + do_CreateInstance(NS_BUFFEREDOUTPUTSTREAM_CONTRACTID, &rv); + if (NS_SUCCEEDED(rv)) { + rv = out->Init(outputStream, aBufferSize); + if (NS_SUCCEEDED(rv)) { + out.forget(aResult); + } + } + return rv; +} + +[[nodiscard]] nsresult NS_NewBufferedInputStream( + nsIInputStream** aResult, already_AddRefed<nsIInputStream> aInputStream, + uint32_t aBufferSize) { + nsCOMPtr<nsIInputStream> inputStream = std::move(aInputStream); + + nsCOMPtr<nsIBufferedInputStream> in; + nsresult rv = nsBufferedInputStream::Create( + nullptr, NS_GET_IID(nsIBufferedInputStream), getter_AddRefs(in)); + if (NS_SUCCEEDED(rv)) { + rv = in->Init(inputStream, aBufferSize); + if (NS_SUCCEEDED(rv)) { + *aResult = static_cast<nsBufferedInputStream*>(in.get()) + ->GetInputStream() + .take(); + } + } + return rv; +} + +Result<nsCOMPtr<nsIInputStream>, nsresult> NS_NewBufferedInputStream( + already_AddRefed<nsIInputStream> aInputStream, uint32_t aBufferSize) { + nsCOMPtr<nsIInputStream> stream; + const nsresult rv = NS_NewBufferedInputStream( + getter_AddRefs(stream), std::move(aInputStream), aBufferSize); + if (NS_SUCCEEDED(rv)) { + return stream; + } + return Err(rv); +} + +namespace { + +#define BUFFER_SIZE 8192 + +class BufferWriter final : public nsIInputStreamCallback { + public: + NS_DECL_THREADSAFE_ISUPPORTS + + BufferWriter(nsIInputStream* aInputStream, void* aBuffer, int64_t aCount) + : mMonitor("BufferWriter.mMonitor"), + mInputStream(aInputStream), + mBuffer(aBuffer), + mCount(aCount), + mWrittenData(0), + mBufferType(aBuffer ? eExternal : eInternal), + mBufferSize(0) { + MOZ_ASSERT(aInputStream); + MOZ_ASSERT(aCount == -1 || aCount > 0); + MOZ_ASSERT_IF(mBuffer, aCount > 0); + } + + nsresult Write() { + NS_ASSERT_OWNINGTHREAD(BufferWriter); + + // Let's make the inputStream buffered if it's not. + if (!NS_InputStreamIsBuffered(mInputStream)) { + nsCOMPtr<nsIInputStream> bufferedStream; + nsresult rv = NS_NewBufferedInputStream( + getter_AddRefs(bufferedStream), mInputStream.forget(), BUFFER_SIZE); + NS_ENSURE_SUCCESS(rv, rv); + + mInputStream = bufferedStream; + } + + mAsyncInputStream = do_QueryInterface(mInputStream); + + if (!mAsyncInputStream) { + return WriteSync(); + } + + // Let's use mAsyncInputStream only. + mInputStream = nullptr; + + return WriteAsync(); + } + + uint64_t WrittenData() const { + NS_ASSERT_OWNINGTHREAD(BufferWriter); + return mWrittenData; + } + + void* StealBuffer() { + NS_ASSERT_OWNINGTHREAD(BufferWriter); + MOZ_ASSERT(mBufferType == eInternal); + + void* buffer = mBuffer; + + mBuffer = nullptr; + mBufferSize = 0; + + return buffer; + } + + private: + ~BufferWriter() { + if (mBuffer && mBufferType == eInternal) { + free(mBuffer); + } + + if (mTaskQueue) { + mTaskQueue->BeginShutdown(); + } + } + + nsresult WriteSync() { + NS_ASSERT_OWNINGTHREAD(BufferWriter); + + uint64_t length = (uint64_t)mCount; + + if (mCount == -1) { + nsresult rv = mInputStream->Available(&length); + NS_ENSURE_SUCCESS(rv, rv); + + if (length == 0) { + // nothing to read. + return NS_OK; + } + } + + if (mBufferType == eInternal) { + mBuffer = malloc(length); + if (NS_WARN_IF(!mBuffer)) { + return NS_ERROR_OUT_OF_MEMORY; + } + } + + uint32_t writtenData; + nsresult rv = mInputStream->ReadSegments(NS_CopySegmentToBuffer, mBuffer, + length, &writtenData); + NS_ENSURE_SUCCESS(rv, rv); + + mWrittenData = writtenData; + return NS_OK; + } + + nsresult WriteAsync() { + NS_ASSERT_OWNINGTHREAD(BufferWriter); + + if (mCount > 0 && mBufferType == eInternal) { + mBuffer = malloc(mCount); + if (NS_WARN_IF(!mBuffer)) { + return NS_ERROR_OUT_OF_MEMORY; + } + } + + while (true) { + if (mCount == -1 && !MaybeExpandBufferSize()) { + return NS_ERROR_OUT_OF_MEMORY; + } + + uint64_t offset = mWrittenData; + uint64_t length = mCount == -1 ? BUFFER_SIZE : mCount; + + // Let's try to read data directly. + uint32_t writtenData; + nsresult rv = mAsyncInputStream->ReadSegments( + NS_CopySegmentToBuffer, static_cast<char*>(mBuffer) + offset, length, + &writtenData); + + // Operation completed. Nothing more to read. + if (NS_SUCCEEDED(rv) && writtenData == 0) { + return NS_OK; + } + + // If we succeeded, let's try to read again. + if (NS_SUCCEEDED(rv)) { + mWrittenData += writtenData; + if (mCount != -1) { + MOZ_ASSERT(mCount >= writtenData); + mCount -= writtenData; + + // Is this the end of the reading? + if (mCount == 0) { + return NS_OK; + } + } + + continue; + } + + // Async wait... + if (rv == NS_BASE_STREAM_WOULD_BLOCK) { + rv = MaybeCreateTaskQueue(); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + MonitorAutoLock lock(mMonitor); + + rv = mAsyncInputStream->AsyncWait(this, 0, length, mTaskQueue); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + lock.Wait(); + continue; + } + + // Otherwise, let's propagate the error. + return rv; + } + + MOZ_ASSERT_UNREACHABLE("We should not be here"); + return NS_ERROR_FAILURE; + } + + nsresult MaybeCreateTaskQueue() { + NS_ASSERT_OWNINGTHREAD(BufferWriter); + + if (!mTaskQueue) { + nsCOMPtr<nsIEventTarget> target = + do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID); + if (!target) { + return NS_ERROR_FAILURE; + } + + mTaskQueue = new TaskQueue(target.forget()); + } + + return NS_OK; + } + + NS_IMETHOD + OnInputStreamReady(nsIAsyncInputStream* aStream) override { + MOZ_ASSERT(!NS_IsMainThread()); + + // We have something to read. Let's unlock the main-thread. + MonitorAutoLock lock(mMonitor); + lock.Notify(); + return NS_OK; + } + + bool MaybeExpandBufferSize() { + NS_ASSERT_OWNINGTHREAD(BufferWriter); + + MOZ_ASSERT(mCount == -1); + + if (mBufferSize >= mWrittenData + BUFFER_SIZE) { + // The buffer is big enough. + return true; + } + + CheckedUint32 bufferSize = + std::max<uint32_t>(static_cast<uint32_t>(mWrittenData), BUFFER_SIZE); + while (bufferSize.isValid() && + bufferSize.value() < mWrittenData + BUFFER_SIZE) { + bufferSize *= 2; + } + + if (!bufferSize.isValid()) { + return false; + } + + void* buffer = realloc(mBuffer, bufferSize.value()); + if (!buffer) { + return false; + } + + mBuffer = buffer; + mBufferSize = bufferSize.value(); + return true; + } + + // All the members of this class are touched on the owning thread only. The + // monitor is only used to communicate when there is more data to read. + Monitor mMonitor; + + nsCOMPtr<nsIInputStream> mInputStream; + nsCOMPtr<nsIAsyncInputStream> mAsyncInputStream; + + RefPtr<TaskQueue> mTaskQueue; + + void* mBuffer; + int64_t mCount; + uint64_t mWrittenData; + + enum { + // The buffer is allocated internally and this object must release it + // in the DTOR if not stolen. The buffer can be reallocated. + eInternal, + + // The buffer is not owned by this object and it cannot be reallocated. + eExternal, + } mBufferType; + + // The following set if needed for the async read. + uint64_t mBufferSize; +}; + +NS_IMPL_ISUPPORTS(BufferWriter, nsIInputStreamCallback) + +} // anonymous namespace + +nsresult NS_ReadInputStreamToBuffer(nsIInputStream* aInputStream, void** aDest, + int64_t aCount, uint64_t* aWritten) { + MOZ_ASSERT(aInputStream); + MOZ_ASSERT(aCount >= -1); + + uint64_t dummyWritten; + if (!aWritten) { + aWritten = &dummyWritten; + } + + if (aCount == 0) { + *aWritten = 0; + return NS_OK; + } + + // This will take care of allocating and reallocating aDest. + RefPtr<BufferWriter> writer = new BufferWriter(aInputStream, *aDest, aCount); + + nsresult rv = writer->Write(); + NS_ENSURE_SUCCESS(rv, rv); + + *aWritten = writer->WrittenData(); + + if (!*aDest) { + *aDest = writer->StealBuffer(); + } + + return NS_OK; +} + +nsresult NS_ReadInputStreamToString(nsIInputStream* aInputStream, + nsACString& aDest, int64_t aCount, + uint64_t* aWritten) { + uint64_t dummyWritten; + if (!aWritten) { + aWritten = &dummyWritten; + } + + // Nothing to do if aCount is 0. + if (aCount == 0) { + aDest.Truncate(); + *aWritten = 0; + return NS_OK; + } + + // If we have the size, we can pre-allocate the buffer. + if (aCount > 0) { + if (NS_WARN_IF(aCount >= INT32_MAX) || + NS_WARN_IF(!aDest.SetLength(aCount, mozilla::fallible))) { + return NS_ERROR_OUT_OF_MEMORY; + } + + void* dest = aDest.BeginWriting(); + nsresult rv = + NS_ReadInputStreamToBuffer(aInputStream, &dest, aCount, aWritten); + NS_ENSURE_SUCCESS(rv, rv); + + if ((uint64_t)aCount > *aWritten) { + aDest.Truncate(*aWritten); + } + + return NS_OK; + } + + // If the size is unknown, BufferWriter will allocate the buffer. + void* dest = nullptr; + nsresult rv = + NS_ReadInputStreamToBuffer(aInputStream, &dest, aCount, aWritten); + MOZ_ASSERT_IF(NS_FAILED(rv), dest == nullptr); + NS_ENSURE_SUCCESS(rv, rv); + + if (!dest) { + MOZ_ASSERT(*aWritten == 0); + aDest.Truncate(); + return NS_OK; + } + + aDest.Adopt(reinterpret_cast<char*>(dest), *aWritten); + return NS_OK; +} + +nsresult NS_NewURI(nsIURI** result, const nsACString& spec, + NotNull<const Encoding*> encoding, + nsIURI* baseURI /* = nullptr */) { + nsAutoCString charset; + encoding->Name(charset); + return NS_NewURI(result, spec, charset.get(), baseURI); +} + +nsresult NS_NewURI(nsIURI** result, const nsAString& aSpec, + const char* charset /* = nullptr */, + nsIURI* baseURI /* = nullptr */) { + nsAutoCString spec; + if (!AppendUTF16toUTF8(aSpec, spec, mozilla::fallible)) { + return NS_ERROR_OUT_OF_MEMORY; + } + return NS_NewURI(result, spec, charset, baseURI); +} + +nsresult NS_NewURI(nsIURI** result, const nsAString& aSpec, + NotNull<const Encoding*> encoding, + nsIURI* baseURI /* = nullptr */) { + nsAutoCString spec; + if (!AppendUTF16toUTF8(aSpec, spec, mozilla::fallible)) { + return NS_ERROR_OUT_OF_MEMORY; + } + return NS_NewURI(result, spec, encoding, baseURI); +} + +nsresult NS_NewURI(nsIURI** result, const char* spec, + nsIURI* baseURI /* = nullptr */) { + return NS_NewURI(result, nsDependentCString(spec), nullptr, baseURI); +} + +static nsresult NewStandardURI(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); +} + +extern MOZ_THREAD_LOCAL(uint32_t) gTlsURLRecursionCount; + +template <typename T> +class TlsAutoIncrement { + public: + explicit TlsAutoIncrement(T& var) : mVar(var) { + mValue = mVar.get(); + mVar.set(mValue + 1); + } + ~TlsAutoIncrement() { + typename T::Type value = mVar.get(); + MOZ_ASSERT(value == mValue + 1); + mVar.set(value - 1); + } + + typename T::Type value() { return mValue; } + + private: + typename T::Type mValue; + T& mVar; +}; + +nsresult NS_NewURI(nsIURI** aURI, const nsACString& aSpec, + const char* aCharset /* = nullptr */, + nsIURI* aBaseURI /* = nullptr */) { + TlsAutoIncrement<decltype(gTlsURLRecursionCount)> inc(gTlsURLRecursionCount); + if (inc.value() >= MAX_RECURSION_COUNT) { + return NS_ERROR_MALFORMED_URI; + } + + nsAutoCString scheme; + nsresult rv = net_ExtractURLScheme(aSpec, scheme); + if (NS_FAILED(rv)) { + // then aSpec is relative + if (!aBaseURI) { + return NS_ERROR_MALFORMED_URI; + } + + if (!aSpec.IsEmpty() && aSpec[0] == '#') { + // Looks like a reference instead of a fully-specified URI. + // --> initialize |uri| as a clone of |aBaseURI|, with ref appended. + return NS_GetURIWithNewRef(aBaseURI, aSpec, aURI); + } + + rv = aBaseURI->GetScheme(scheme); + if (NS_FAILED(rv)) return rv; + } + + if (scheme.EqualsLiteral("http") || scheme.EqualsLiteral("ws")) { + return NewStandardURI(aSpec, aCharset, aBaseURI, NS_HTTP_DEFAULT_PORT, + aURI); + } + if (scheme.EqualsLiteral("https") || scheme.EqualsLiteral("wss")) { + return NewStandardURI(aSpec, aCharset, aBaseURI, NS_HTTPS_DEFAULT_PORT, + aURI); + } + if (scheme.EqualsLiteral("ftp")) { + return NewStandardURI(aSpec, aCharset, aBaseURI, 21, aURI); + } + if (scheme.EqualsLiteral("ssh")) { + return NewStandardURI(aSpec, aCharset, aBaseURI, 22, aURI); + } + + if (scheme.EqualsLiteral("file")) { + nsAutoCString buf(aSpec); +#if defined(XP_WIN) + buf.Truncate(); + if (!net_NormalizeFileURL(aSpec, buf)) { + buf = aSpec; + } +#endif + + nsCOMPtr<nsIURI> base(aBaseURI); + return NS_MutateURI(new nsStandardURL::Mutator()) + .Apply(NS_MutatorMethod(&nsIFileURLMutator::MarkFileURL)) + .Apply(NS_MutatorMethod(&nsIStandardURLMutator::Init, + nsIStandardURL::URLTYPE_NO_AUTHORITY, -1, buf, + aCharset, base, nullptr)) + .Finalize(aURI); + } + + if (scheme.EqualsLiteral("data")) { + return nsDataHandler::CreateNewURI(aSpec, aCharset, aBaseURI, aURI); + } + + if (scheme.EqualsLiteral("moz-safe-about") || + scheme.EqualsLiteral("page-icon") || scheme.EqualsLiteral("moz") || + scheme.EqualsLiteral("moz-anno") || + scheme.EqualsLiteral("moz-fonttable")) { + return NS_MutateURI(new nsSimpleURI::Mutator()) + .SetSpec(aSpec) + .Finalize(aURI); + } + + if (scheme.EqualsLiteral("chrome")) { + return nsChromeProtocolHandler::CreateNewURI(aSpec, aCharset, aBaseURI, + aURI); + } + + if (scheme.EqualsLiteral("javascript")) { + return nsJSProtocolHandler::CreateNewURI(aSpec, aCharset, aBaseURI, aURI); + } + + if (scheme.EqualsLiteral("blob")) { + return BlobURLProtocolHandler::CreateNewURI(aSpec, aCharset, aBaseURI, + aURI); + } + + if (scheme.EqualsLiteral("view-source")) { + return nsViewSourceHandler::CreateNewURI(aSpec, aCharset, aBaseURI, aURI); + } + + if (scheme.EqualsLiteral("resource")) { + RefPtr<nsResProtocolHandler> handler = nsResProtocolHandler::GetSingleton(); + if (!handler) { + return NS_ERROR_NOT_AVAILABLE; + } + return handler->NewURI(aSpec, aCharset, aBaseURI, aURI); + } + + if (scheme.EqualsLiteral("indexeddb")) { + nsCOMPtr<nsIURI> base(aBaseURI); + return NS_MutateURI(new nsStandardURL::Mutator()) + .Apply(NS_MutatorMethod(&nsIStandardURLMutator::Init, + nsIStandardURL::URLTYPE_AUTHORITY, 0, + nsCString(aSpec), aCharset, base, nullptr)) + .Finalize(aURI); + } + + if (scheme.EqualsLiteral("moz-extension")) { + RefPtr<mozilla::net::ExtensionProtocolHandler> handler = + mozilla::net::ExtensionProtocolHandler::GetSingleton(); + if (!handler) { + return NS_ERROR_NOT_AVAILABLE; + } + return handler->NewURI(aSpec, aCharset, aBaseURI, aURI); + } + + if (scheme.EqualsLiteral("moz-page-thumb")) { + // The moz-page-thumb service runs JS to resolve a URI to a + // storage location, so this should only ever run on the main + // thread. + if (!NS_IsMainThread()) { + return NS_ERROR_NOT_AVAILABLE; + } + + RefPtr<mozilla::net::PageThumbProtocolHandler> handler = + mozilla::net::PageThumbProtocolHandler::GetSingleton(); + if (!handler) { + return NS_ERROR_NOT_AVAILABLE; + } + return handler->NewURI(aSpec, aCharset, aBaseURI, aURI); + } + + if (scheme.EqualsLiteral("about")) { + return nsAboutProtocolHandler::CreateNewURI(aSpec, aCharset, aBaseURI, + aURI); + } + + if (scheme.EqualsLiteral("jar")) { + nsCOMPtr<nsIURI> base(aBaseURI); + return NS_MutateURI(new nsJARURI::Mutator()) + .Apply(NS_MutatorMethod(&nsIJARURIMutator::SetSpecBaseCharset, + nsCString(aSpec), base, aCharset)) + .Finalize(aURI); + } + + if (scheme.EqualsLiteral("moz-icon")) { + return NS_MutateURI(new nsMozIconURI::Mutator()) + .SetSpec(aSpec) + .Finalize(aURI); + } + +#ifdef MOZ_WIDGET_GTK + if (scheme.EqualsLiteral("smb") || scheme.EqualsLiteral("sftp")) { + nsCOMPtr<nsIURI> base(aBaseURI); + return NS_MutateURI(new nsStandardURL::Mutator()) + .Apply(NS_MutatorMethod(&nsIStandardURLMutator::Init, + nsIStandardURL::URLTYPE_STANDARD, -1, + nsCString(aSpec), aCharset, base, nullptr)) + .Finalize(aURI); + } +#endif + + if (scheme.EqualsLiteral("android")) { + nsCOMPtr<nsIURI> base(aBaseURI); + return NS_MutateURI(NS_STANDARDURLMUTATOR_CONTRACTID) + .Apply(NS_MutatorMethod(&nsIStandardURLMutator::Init, + nsIStandardURL::URLTYPE_STANDARD, -1, + nsCString(aSpec), aCharset, base, nullptr)) + .Finalize(aURI); + } + + // web-extensions can add custom protocol implementations with standard URLs + // that have notion of hostname, authority and relative URLs. Below we + // manually check agains set of known protocols schemes until more general + // solution is in place (See Bug 1569733) + if (!StaticPrefs::network_url_useDefaultURI()) { + if (scheme.EqualsLiteral("dweb") || scheme.EqualsLiteral("dat") || + scheme.EqualsLiteral("ipfs") || scheme.EqualsLiteral("ipns") || + scheme.EqualsLiteral("ssb") || scheme.EqualsLiteral("wtp")) { + return NewStandardURI(aSpec, aCharset, aBaseURI, -1, aURI); + } + } + +#if defined(MOZ_THUNDERBIRD) || defined(MOZ_SUITE) + rv = NS_NewMailnewsURI(aURI, aSpec, aCharset, aBaseURI); + if (rv != NS_ERROR_UNKNOWN_PROTOCOL) { + return rv; + } +#endif + + if (aBaseURI) { + nsAutoCString newSpec; + rv = aBaseURI->Resolve(aSpec, newSpec); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoCString newScheme; + rv = net_ExtractURLScheme(newSpec, newScheme); + if (NS_SUCCEEDED(rv)) { + // The scheme shouldn't really change at this point. + MOZ_DIAGNOSTIC_ASSERT(newScheme == scheme); + } + + if (StaticPrefs::network_url_useDefaultURI()) { + return NS_MutateURI(new DefaultURI::Mutator()) + .SetSpec(newSpec) + .Finalize(aURI); + } + + return NS_MutateURI(new nsSimpleURI::Mutator()) + .SetSpec(newSpec) + .Finalize(aURI); + } + + if (StaticPrefs::network_url_useDefaultURI()) { + return NS_MutateURI(new DefaultURI::Mutator()) + .SetSpec(aSpec) + .Finalize(aURI); + } + + // Falls back to external protocol handler. + return NS_MutateURI(new nsSimpleURI::Mutator()).SetSpec(aSpec).Finalize(aURI); +} + +nsresult NS_GetSanitizedURIStringFromURI(nsIURI* aUri, + nsAString& aSanitizedSpec) { + aSanitizedSpec.Truncate(); + + nsCOMPtr<nsISensitiveInfoHiddenURI> safeUri = do_QueryInterface(aUri); + nsAutoCString cSpec; + nsresult rv; + if (safeUri) { + rv = safeUri->GetSensitiveInfoHiddenSpec(cSpec); + } else { + rv = aUri->GetSpec(cSpec); + } + + if (NS_SUCCEEDED(rv)) { + aSanitizedSpec.Assign(NS_ConvertUTF8toUTF16(cSpec)); + } + return rv; +} + +nsresult NS_LoadPersistentPropertiesFromURISpec( + nsIPersistentProperties** outResult, const nsACString& aSpec) { + nsCOMPtr<nsIURI> uri; + nsresult rv = NS_NewURI(getter_AddRefs(uri), aSpec); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIChannel> channel; + rv = NS_NewChannel(getter_AddRefs(channel), uri, + nsContentUtils::GetSystemPrincipal(), + nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL, + nsIContentPolicy::TYPE_OTHER); + NS_ENSURE_SUCCESS(rv, rv); + nsCOMPtr<nsIInputStream> in; + rv = channel->Open(getter_AddRefs(in)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIPersistentProperties> properties = new nsPersistentProperties(); + rv = properties->Load(in); + NS_ENSURE_SUCCESS(rv, rv); + + properties.swap(*outResult); + return NS_OK; +} + +bool NS_UsePrivateBrowsing(nsIChannel* channel) { + OriginAttributes attrs; + bool result = StoragePrincipalHelper::GetOriginAttributes( + channel, attrs, StoragePrincipalHelper::eRegularPrincipal); + NS_ENSURE_TRUE(result, result); + return attrs.mPrivateBrowsingId > 0; +} + +bool NS_HasBeenCrossOrigin(nsIChannel* aChannel, bool aReport) { + nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo(); + // TYPE_DOCUMENT loads have a null LoadingPrincipal and can not be cross + // origin. + if (!loadInfo->GetLoadingPrincipal()) { + return false; + } + + // Always treat tainted channels as cross-origin. + if (loadInfo->GetTainting() != LoadTainting::Basic) { + return true; + } + + nsCOMPtr<nsIPrincipal> loadingPrincipal = loadInfo->GetLoadingPrincipal(); + uint32_t mode = loadInfo->GetSecurityMode(); + bool dataInherits = + mode == nsILoadInfo::SEC_REQUIRE_SAME_ORIGIN_INHERITS_SEC_CONTEXT || + mode == nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_INHERITS_SEC_CONTEXT || + mode == nsILoadInfo::SEC_REQUIRE_CORS_INHERITS_SEC_CONTEXT; + + bool aboutBlankInherits = dataInherits && loadInfo->GetAboutBlankInherits(); + + uint64_t innerWindowID = loadInfo->GetInnerWindowID(); + + for (nsIRedirectHistoryEntry* redirectHistoryEntry : + loadInfo->RedirectChain()) { + nsCOMPtr<nsIPrincipal> principal; + redirectHistoryEntry->GetPrincipal(getter_AddRefs(principal)); + if (!principal) { + return true; + } + + nsCOMPtr<nsIURI> uri; + auto* basePrin = BasePrincipal::Cast(principal); + basePrin->GetURI(getter_AddRefs(uri)); + if (!uri) { + return true; + } + + if (aboutBlankInherits && NS_IsAboutBlank(uri)) { + continue; + } + + nsresult res; + if (aReport) { + res = loadingPrincipal->CheckMayLoadWithReporting(uri, dataInherits, + innerWindowID); + } else { + res = loadingPrincipal->CheckMayLoad(uri, dataInherits); + } + if (NS_FAILED(res)) { + return true; + } + } + + nsCOMPtr<nsIURI> uri; + NS_GetFinalChannelURI(aChannel, getter_AddRefs(uri)); + if (!uri) { + return true; + } + + if (aboutBlankInherits && NS_IsAboutBlank(uri)) { + return false; + } + + nsresult res; + if (aReport) { + res = loadingPrincipal->CheckMayLoadWithReporting(uri, dataInherits, + innerWindowID); + } else { + res = loadingPrincipal->CheckMayLoad(uri, dataInherits); + } + + return NS_FAILED(res); +} + +bool NS_IsSafeMethodNav(nsIChannel* aChannel) { + RefPtr<HttpBaseChannel> baseChan = do_QueryObject(aChannel); + if (!baseChan) { + return false; + } + nsHttpRequestHead* requestHead = baseChan->GetRequestHead(); + if (!requestHead) { + return false; + } + return requestHead->IsSafeMethod(); +} + +bool NS_ShouldCheckAppCache(nsIPrincipal* aPrincipal) { + uint32_t privateBrowsingId = 0; + nsresult rv = aPrincipal->GetPrivateBrowsingId(&privateBrowsingId); + if (NS_SUCCEEDED(rv) && (privateBrowsingId > 0)) { + return false; + } + + nsCOMPtr<nsIOfflineCacheUpdateService> offlineService = + do_GetService("@mozilla.org/offlinecacheupdate-service;1"); + if (!offlineService) { + return false; + } + + bool allowed; + rv = offlineService->OfflineAppAllowed(aPrincipal, &allowed); + return NS_SUCCEEDED(rv) && allowed; +} + +void NS_WrapAuthPrompt(nsIAuthPrompt* aAuthPrompt, + nsIAuthPrompt2** aAuthPrompt2) { + nsCOMPtr<nsIAuthPromptAdapterFactory> factory = + do_GetService(NS_AUTHPROMPT_ADAPTER_FACTORY_CONTRACTID); + if (!factory) return; + + NS_WARNING("Using deprecated nsIAuthPrompt"); + factory->CreateAdapter(aAuthPrompt, aAuthPrompt2); +} + +void NS_QueryAuthPrompt2(nsIInterfaceRequestor* aCallbacks, + nsIAuthPrompt2** aAuthPrompt) { + CallGetInterface(aCallbacks, aAuthPrompt); + if (*aAuthPrompt) return; + + // Maybe only nsIAuthPrompt is provided and we have to wrap it. + nsCOMPtr<nsIAuthPrompt> prompt(do_GetInterface(aCallbacks)); + if (!prompt) return; + + NS_WrapAuthPrompt(prompt, aAuthPrompt); +} + +void NS_QueryAuthPrompt2(nsIChannel* aChannel, nsIAuthPrompt2** aAuthPrompt) { + *aAuthPrompt = nullptr; + + // We want to use any auth prompt we can find on the channel's callbacks, + // and if that fails use the loadgroup's prompt (if any) + // Therefore, we can't just use NS_QueryNotificationCallbacks, because + // that would prefer a loadgroup's nsIAuthPrompt2 over a channel's + // nsIAuthPrompt. + nsCOMPtr<nsIInterfaceRequestor> callbacks; + aChannel->GetNotificationCallbacks(getter_AddRefs(callbacks)); + if (callbacks) { + NS_QueryAuthPrompt2(callbacks, aAuthPrompt); + if (*aAuthPrompt) return; + } + + nsCOMPtr<nsILoadGroup> group; + aChannel->GetLoadGroup(getter_AddRefs(group)); + if (!group) return; + + group->GetNotificationCallbacks(getter_AddRefs(callbacks)); + if (!callbacks) return; + NS_QueryAuthPrompt2(callbacks, aAuthPrompt); +} + +nsresult NS_NewNotificationCallbacksAggregation( + nsIInterfaceRequestor* callbacks, nsILoadGroup* loadGroup, + nsIEventTarget* target, nsIInterfaceRequestor** result) { + nsCOMPtr<nsIInterfaceRequestor> cbs; + if (loadGroup) loadGroup->GetNotificationCallbacks(getter_AddRefs(cbs)); + return NS_NewInterfaceRequestorAggregation(callbacks, cbs, target, result); +} + +nsresult NS_NewNotificationCallbacksAggregation( + nsIInterfaceRequestor* callbacks, nsILoadGroup* loadGroup, + nsIInterfaceRequestor** result) { + return NS_NewNotificationCallbacksAggregation(callbacks, loadGroup, nullptr, + result); +} + +nsresult NS_DoImplGetInnermostURI(nsINestedURI* nestedURI, nsIURI** result) { + MOZ_ASSERT(nestedURI, "Must have a nested URI!"); + MOZ_ASSERT(!*result, "Must have null *result"); + + nsCOMPtr<nsIURI> inner; + nsresult rv = nestedURI->GetInnerURI(getter_AddRefs(inner)); + NS_ENSURE_SUCCESS(rv, rv); + + // We may need to loop here until we reach the innermost + // URI. + nsCOMPtr<nsINestedURI> nestedInner(do_QueryInterface(inner)); + while (nestedInner) { + rv = nestedInner->GetInnerURI(getter_AddRefs(inner)); + NS_ENSURE_SUCCESS(rv, rv); + nestedInner = do_QueryInterface(inner); + } + + // Found the innermost one if we reach here. + inner.swap(*result); + + return rv; +} + +nsresult NS_ImplGetInnermostURI(nsINestedURI* nestedURI, nsIURI** result) { + // Make it safe to use swap() + *result = nullptr; + + return NS_DoImplGetInnermostURI(nestedURI, result); +} + +already_AddRefed<nsIURI> NS_GetInnermostURI(nsIURI* aURI) { + MOZ_ASSERT(aURI, "Must have URI"); + + nsCOMPtr<nsIURI> uri = aURI; + + nsCOMPtr<nsINestedURI> nestedURI(do_QueryInterface(uri)); + if (!nestedURI) { + return uri.forget(); + } + + nsresult rv = nestedURI->GetInnermostURI(getter_AddRefs(uri)); + if (NS_FAILED(rv)) { + return nullptr; + } + + return uri.forget(); +} + +nsresult NS_GetFinalChannelURI(nsIChannel* channel, nsIURI** uri) { + *uri = nullptr; + + nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo(); + nsCOMPtr<nsIURI> resultPrincipalURI; + loadInfo->GetResultPrincipalURI(getter_AddRefs(resultPrincipalURI)); + if (resultPrincipalURI) { + resultPrincipalURI.forget(uri); + return NS_OK; + } + return channel->GetOriginalURI(uri); +} + +nsresult NS_URIChainHasFlags(nsIURI* uri, uint32_t flags, bool* result) { + nsresult rv; + nsCOMPtr<nsINetUtil> util = do_GetNetUtil(&rv); + NS_ENSURE_SUCCESS(rv, rv); + + return util->URIChainHasFlags(uri, flags, result); +} + +uint32_t NS_SecurityHashURI(nsIURI* aURI) { + nsCOMPtr<nsIURI> baseURI = NS_GetInnermostURI(aURI); + + nsAutoCString scheme; + uint32_t schemeHash = 0; + if (NS_SUCCEEDED(baseURI->GetScheme(scheme))) + schemeHash = mozilla::HashString(scheme); + + // TODO figure out how to hash file:// URIs + if (scheme.EqualsLiteral("file")) return schemeHash; // sad face + +#if IS_ORIGIN_IS_FULL_SPEC_DEFINED + bool hasFlag; + if (NS_FAILED(NS_URIChainHasFlags( + baseURI, nsIProtocolHandler::ORIGIN_IS_FULL_SPEC, &hasFlag)) || + hasFlag) { + nsAutoCString spec; + uint32_t specHash; + nsresult res = baseURI->GetSpec(spec); + if (NS_SUCCEEDED(res)) + specHash = mozilla::HashString(spec); + else + specHash = static_cast<uint32_t>(res); + return specHash; + } +#endif + + nsAutoCString host; + uint32_t hostHash = 0; + if (NS_SUCCEEDED(baseURI->GetAsciiHost(host))) + hostHash = mozilla::HashString(host); + + return mozilla::AddToHash(schemeHash, hostHash, NS_GetRealPort(baseURI)); +} + +bool NS_SecurityCompareURIs(nsIURI* aSourceURI, nsIURI* aTargetURI, + bool aStrictFileOriginPolicy) { + nsresult rv; + + // Note that this is not an Equals() test on purpose -- for URIs that don't + // support host/port, we want equality to basically be object identity, for + // security purposes. Otherwise, for example, two javascript: URIs that + // are otherwise unrelated could end up "same origin", which would be + // unfortunate. + if (aSourceURI && aSourceURI == aTargetURI) { + return true; + } + + if (!aTargetURI || !aSourceURI) { + return false; + } + + // If either URI is a nested URI, get the base URI + nsCOMPtr<nsIURI> sourceBaseURI = NS_GetInnermostURI(aSourceURI); + nsCOMPtr<nsIURI> targetBaseURI = NS_GetInnermostURI(aTargetURI); + +#if defined(MOZ_THUNDERBIRD) || defined(MOZ_SUITE) + // Check if either URI has a special origin. + nsCOMPtr<nsIURI> origin; + nsCOMPtr<nsIURIWithSpecialOrigin> uriWithSpecialOrigin = + do_QueryInterface(sourceBaseURI); + if (uriWithSpecialOrigin) { + rv = uriWithSpecialOrigin->GetOrigin(getter_AddRefs(origin)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return false; + } + MOZ_ASSERT(origin); + sourceBaseURI = origin; + } + uriWithSpecialOrigin = do_QueryInterface(targetBaseURI); + if (uriWithSpecialOrigin) { + rv = uriWithSpecialOrigin->GetOrigin(getter_AddRefs(origin)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return false; + } + MOZ_ASSERT(origin); + targetBaseURI = origin; + } +#endif + + nsCOMPtr<nsIPrincipal> sourceBlobPrincipal; + if (BlobURLProtocolHandler::GetBlobURLPrincipal( + sourceBaseURI, getter_AddRefs(sourceBlobPrincipal))) { + nsCOMPtr<nsIURI> sourceBlobOwnerURI; + auto* basePrin = BasePrincipal::Cast(sourceBlobPrincipal); + rv = basePrin->GetURI(getter_AddRefs(sourceBlobOwnerURI)); + if (NS_SUCCEEDED(rv)) { + sourceBaseURI = sourceBlobOwnerURI; + } + } + + nsCOMPtr<nsIPrincipal> targetBlobPrincipal; + if (BlobURLProtocolHandler::GetBlobURLPrincipal( + targetBaseURI, getter_AddRefs(targetBlobPrincipal))) { + nsCOMPtr<nsIURI> targetBlobOwnerURI; + auto* basePrin = BasePrincipal::Cast(targetBlobPrincipal); + rv = basePrin->GetURI(getter_AddRefs(targetBlobOwnerURI)); + if (NS_SUCCEEDED(rv)) { + targetBaseURI = targetBlobOwnerURI; + } + } + + if (!sourceBaseURI || !targetBaseURI) return false; + + // Compare schemes + nsAutoCString targetScheme; + bool sameScheme = false; + if (NS_FAILED(targetBaseURI->GetScheme(targetScheme)) || + NS_FAILED(sourceBaseURI->SchemeIs(targetScheme.get(), &sameScheme)) || + !sameScheme) { + // Not same-origin if schemes differ + return false; + } + + // For file scheme, reject unless the files are identical. See + // NS_RelaxStrictFileOriginPolicy for enforcing file same-origin checking + if (targetScheme.EqualsLiteral("file")) { + // in traditional unsafe behavior all files are the same origin + if (!aStrictFileOriginPolicy) return true; + + nsCOMPtr<nsIFileURL> sourceFileURL(do_QueryInterface(sourceBaseURI)); + nsCOMPtr<nsIFileURL> targetFileURL(do_QueryInterface(targetBaseURI)); + + if (!sourceFileURL || !targetFileURL) return false; + + nsCOMPtr<nsIFile> sourceFile, targetFile; + + sourceFileURL->GetFile(getter_AddRefs(sourceFile)); + targetFileURL->GetFile(getter_AddRefs(targetFile)); + + if (!sourceFile || !targetFile) return false; + + // Otherwise they had better match + bool filesAreEqual = false; + rv = sourceFile->Equals(targetFile, &filesAreEqual); + return NS_SUCCEEDED(rv) && filesAreEqual; + } + +#if IS_ORIGIN_IS_FULL_SPEC_DEFINED + bool hasFlag; + if (NS_FAILED(NS_URIChainHasFlags( + targetBaseURI, nsIProtocolHandler::ORIGIN_IS_FULL_SPEC, &hasFlag)) || + hasFlag) { + // URIs with this flag have the whole spec as a distinct trust + // domain; use the whole spec for comparison + nsAutoCString targetSpec; + nsAutoCString sourceSpec; + return (NS_SUCCEEDED(targetBaseURI->GetSpec(targetSpec)) && + NS_SUCCEEDED(sourceBaseURI->GetSpec(sourceSpec)) && + targetSpec.Equals(sourceSpec)); + } +#endif + + // Compare hosts + nsAutoCString targetHost; + nsAutoCString sourceHost; + if (NS_FAILED(targetBaseURI->GetAsciiHost(targetHost)) || + NS_FAILED(sourceBaseURI->GetAsciiHost(sourceHost))) { + return false; + } + + nsCOMPtr<nsIStandardURL> targetURL(do_QueryInterface(targetBaseURI)); + nsCOMPtr<nsIStandardURL> sourceURL(do_QueryInterface(sourceBaseURI)); + if (!targetURL || !sourceURL) { + return false; + } + + if (!targetHost.Equals(sourceHost, nsCaseInsensitiveCStringComparator)) { + return false; + } + + return NS_GetRealPort(targetBaseURI) == NS_GetRealPort(sourceBaseURI); +} + +bool NS_URIIsLocalFile(nsIURI* aURI) { + nsCOMPtr<nsINetUtil> util = do_GetNetUtil(); + + bool isFile; + return util && + NS_SUCCEEDED(util->ProtocolHasFlags( + aURI, nsIProtocolHandler::URI_IS_LOCAL_FILE, &isFile)) && + isFile; +} + +bool NS_RelaxStrictFileOriginPolicy(nsIURI* aTargetURI, nsIURI* aSourceURI, + bool aAllowDirectoryTarget /* = false */) { + if (!NS_URIIsLocalFile(aTargetURI)) { + // This is probably not what the caller intended + MOZ_ASSERT_UNREACHABLE( + "NS_RelaxStrictFileOriginPolicy called with non-file URI"); + return false; + } + + if (!NS_URIIsLocalFile(aSourceURI)) { + // If the source is not also a file: uri then forget it + // (don't want resource: principals in a file: doc) + // + // note: we're not de-nesting jar: uris here, we want to + // keep archive content bottled up in its own little island + return false; + } + + // + // pull out the internal files + // + nsCOMPtr<nsIFileURL> targetFileURL(do_QueryInterface(aTargetURI)); + nsCOMPtr<nsIFileURL> sourceFileURL(do_QueryInterface(aSourceURI)); + nsCOMPtr<nsIFile> targetFile; + nsCOMPtr<nsIFile> sourceFile; + bool targetIsDir; + + // Make sure targetFile is not a directory (bug 209234) + // and that it exists w/out unescaping (bug 395343) + if (!sourceFileURL || !targetFileURL || + NS_FAILED(targetFileURL->GetFile(getter_AddRefs(targetFile))) || + NS_FAILED(sourceFileURL->GetFile(getter_AddRefs(sourceFile))) || + !targetFile || !sourceFile || NS_FAILED(targetFile->Normalize()) || +#ifndef MOZ_WIDGET_ANDROID + NS_FAILED(sourceFile->Normalize()) || +#endif + (!aAllowDirectoryTarget && + (NS_FAILED(targetFile->IsDirectory(&targetIsDir)) || targetIsDir))) { + return false; + } + + if (!StaticPrefs::privacy_file_unique_origin()) { + // + // If the file to be loaded is in a subdirectory of the source + // (or same-dir if source is not a directory) then it will + // inherit its source principal and be scriptable by that source. + // + bool sourceIsDir; + bool allowed = false; + nsresult rv = sourceFile->IsDirectory(&sourceIsDir); + if (NS_SUCCEEDED(rv) && sourceIsDir) { + rv = sourceFile->Contains(targetFile, &allowed); + } else { + nsCOMPtr<nsIFile> sourceParent; + rv = sourceFile->GetParent(getter_AddRefs(sourceParent)); + if (NS_SUCCEEDED(rv) && sourceParent) { + rv = sourceParent->Equals(targetFile, &allowed); + if (NS_FAILED(rv) || !allowed) { + rv = sourceParent->Contains(targetFile, &allowed); + } else { + MOZ_ASSERT(aAllowDirectoryTarget, + "sourceFile->Parent == targetFile, but targetFile " + "should've been disallowed if it is a directory"); + } + } + } + + if (NS_SUCCEEDED(rv) && allowed) { + return true; + } + } + + return false; +} + +bool NS_IsInternalSameURIRedirect(nsIChannel* aOldChannel, + nsIChannel* aNewChannel, uint32_t aFlags) { + if (!(aFlags & nsIChannelEventSink::REDIRECT_INTERNAL)) { + return false; + } + + nsCOMPtr<nsIURI> oldURI, newURI; + aOldChannel->GetURI(getter_AddRefs(oldURI)); + aNewChannel->GetURI(getter_AddRefs(newURI)); + + if (!oldURI || !newURI) { + return false; + } + + bool res; + return NS_SUCCEEDED(oldURI->Equals(newURI, &res)) && res; +} + +bool NS_IsHSTSUpgradeRedirect(nsIChannel* aOldChannel, nsIChannel* aNewChannel, + uint32_t aFlags) { + if (!(aFlags & nsIChannelEventSink::REDIRECT_STS_UPGRADE)) { + return false; + } + + nsCOMPtr<nsIURI> oldURI, newURI; + aOldChannel->GetURI(getter_AddRefs(oldURI)); + aNewChannel->GetURI(getter_AddRefs(newURI)); + + if (!oldURI || !newURI) { + return false; + } + + if (!oldURI->SchemeIs("http")) { + return false; + } + + nsCOMPtr<nsIURI> upgradedURI; + nsresult rv = NS_GetSecureUpgradedURI(oldURI, getter_AddRefs(upgradedURI)); + if (NS_FAILED(rv)) { + return false; + } + + bool res; + return NS_SUCCEEDED(upgradedURI->Equals(newURI, &res)) && res; +} + +nsresult NS_LinkRedirectChannels(uint64_t channelId, + nsIParentChannel* parentChannel, + nsIChannel** _result) { + nsCOMPtr<nsIRedirectChannelRegistrar> registrar = + RedirectChannelRegistrar::GetOrCreate(); + MOZ_ASSERT(registrar); + + return registrar->LinkChannels(channelId, parentChannel, _result); +} + +nsresult NS_MaybeOpenChannelUsingOpen(nsIChannel* aChannel, + nsIInputStream** aStream) { + nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo(); + return aChannel->Open(aStream); +} + +nsresult NS_MaybeOpenChannelUsingAsyncOpen(nsIChannel* aChannel, + nsIStreamListener* aListener) { + nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo(); + return aChannel->AsyncOpen(aListener); +} + +nsILoadInfo::CrossOriginEmbedderPolicy +NS_GetCrossOriginEmbedderPolicyFromHeader(const nsACString& aHeader) { + nsCOMPtr<nsISFVService> sfv = GetSFVService(); + + nsCOMPtr<nsISFVItem> item; + nsresult rv = sfv->ParseItem(aHeader, getter_AddRefs(item)); + if (NS_FAILED(rv)) { + return nsILoadInfo::EMBEDDER_POLICY_NULL; + } + + nsCOMPtr<nsISFVBareItem> value; + rv = item->GetValue(getter_AddRefs(value)); + if (NS_FAILED(rv)) { + return nsILoadInfo::EMBEDDER_POLICY_NULL; + } + + nsCOMPtr<nsISFVToken> token = do_QueryInterface(value); + if (!token) { + return nsILoadInfo::EMBEDDER_POLICY_NULL; + } + + nsAutoCString embedderPolicy; + rv = token->GetValue(embedderPolicy); + if (NS_FAILED(rv)) { + return nsILoadInfo::EMBEDDER_POLICY_NULL; + } + + return embedderPolicy.EqualsLiteral("require-corp") + ? nsILoadInfo::EMBEDDER_POLICY_REQUIRE_CORP + : nsILoadInfo::EMBEDDER_POLICY_NULL; +} + +/** Given the first (disposition) token from a Content-Disposition header, + * tell whether it indicates the content is inline or attachment + * @param aDispToken the disposition token from the content-disposition header + */ +uint32_t NS_GetContentDispositionFromToken(const nsAString& aDispToken) { + // RFC 2183, section 2.8 says that an unknown disposition + // value should be treated as "attachment" + // If all of these tests eval to false, then we have a content-disposition of + // "attachment" or unknown + if (aDispToken.IsEmpty() || aDispToken.LowerCaseEqualsLiteral("inline") || + // Broken sites just send + // Content-Disposition: filename="file" + // without a disposition token... screen those out. + StringHead(aDispToken, 8).LowerCaseEqualsLiteral("filename")) + return nsIChannel::DISPOSITION_INLINE; + + return nsIChannel::DISPOSITION_ATTACHMENT; +} + +uint32_t NS_GetContentDispositionFromHeader(const nsACString& aHeader, + nsIChannel* aChan /* = nullptr */) { + nsresult rv; + nsCOMPtr<nsIMIMEHeaderParam> mimehdrpar = + do_GetService(NS_MIMEHEADERPARAM_CONTRACTID, &rv); + if (NS_FAILED(rv)) return nsIChannel::DISPOSITION_ATTACHMENT; + + nsAutoString dispToken; + rv = mimehdrpar->GetParameterHTTP(aHeader, "", ""_ns, true, nullptr, + dispToken); + + if (NS_FAILED(rv)) { + // special case (see bug 272541): empty disposition type handled as "inline" + if (rv == NS_ERROR_FIRST_HEADER_FIELD_COMPONENT_EMPTY) + return nsIChannel::DISPOSITION_INLINE; + return nsIChannel::DISPOSITION_ATTACHMENT; + } + + return NS_GetContentDispositionFromToken(dispToken); +} + +nsresult NS_GetFilenameFromDisposition(nsAString& aFilename, + const nsACString& aDisposition) { + aFilename.Truncate(); + + nsresult rv; + nsCOMPtr<nsIMIMEHeaderParam> mimehdrpar = + do_GetService(NS_MIMEHEADERPARAM_CONTRACTID, &rv); + if (NS_FAILED(rv)) return rv; + + // Get the value of 'filename' parameter + rv = mimehdrpar->GetParameterHTTP(aDisposition, "filename", ""_ns, true, + nullptr, aFilename); + + if (NS_FAILED(rv)) { + aFilename.Truncate(); + return rv; + } + + if (aFilename.IsEmpty()) return NS_ERROR_NOT_AVAILABLE; + + // Filename may still be percent-encoded. Fix: + if (aFilename.FindChar('%') != -1) { + nsCOMPtr<nsITextToSubURI> textToSubURI = + do_GetService(NS_ITEXTTOSUBURI_CONTRACTID, &rv); + if (NS_SUCCEEDED(rv)) { + nsAutoString unescaped; + textToSubURI->UnEscapeURIForUI(NS_ConvertUTF16toUTF8(aFilename), + unescaped); + aFilename.Assign(unescaped); + } + } + + return NS_OK; +} + +void net_EnsurePSMInit() { + if (XRE_IsSocketProcess()) { + EnsureNSSInitializedChromeOrContent(); + return; + } + + MOZ_ASSERT(XRE_IsParentProcess()); + MOZ_ASSERT(NS_IsMainThread()); + + DebugOnly<bool> rv = EnsureNSSInitializedChromeOrContent(); + MOZ_ASSERT(rv); +} + +bool NS_IsAboutBlank(nsIURI* uri) { + // GetSpec can be expensive for some URIs, so check the scheme first. + if (!uri->SchemeIs("about")) { + return false; + } + + return uri->GetSpecOrDefault().EqualsLiteral("about:blank"); +} + +nsresult NS_GenerateHostPort(const nsCString& host, int32_t port, + nsACString& hostLine) { + if (strchr(host.get(), ':')) { + // host is an IPv6 address literal and must be encapsulated in []'s + hostLine.Assign('['); + // scope id is not needed for Host header. + int scopeIdPos = host.FindChar('%'); + if (scopeIdPos == -1) + hostLine.Append(host); + else if (scopeIdPos > 0) + hostLine.Append(Substring(host, 0, scopeIdPos)); + else + return NS_ERROR_MALFORMED_URI; + hostLine.Append(']'); + } else + hostLine.Assign(host); + if (port != -1) { + hostLine.Append(':'); + hostLine.AppendInt(port); + } + return NS_OK; +} + +void NS_SniffContent(const char* aSnifferType, nsIRequest* aRequest, + const uint8_t* aData, uint32_t aLength, + nsACString& aSniffedType) { + typedef nsCategoryCache<nsIContentSniffer> ContentSnifferCache; + extern ContentSnifferCache* gNetSniffers; + extern ContentSnifferCache* gDataSniffers; + ContentSnifferCache* cache = nullptr; + if (!strcmp(aSnifferType, NS_CONTENT_SNIFFER_CATEGORY)) { + if (!gNetSniffers) { + gNetSniffers = new ContentSnifferCache(NS_CONTENT_SNIFFER_CATEGORY); + } + cache = gNetSniffers; + } else if (!strcmp(aSnifferType, NS_DATA_SNIFFER_CATEGORY)) { + if (!gDataSniffers) { + gDataSniffers = new ContentSnifferCache(NS_DATA_SNIFFER_CATEGORY); + } + cache = gDataSniffers; + } else { + // Invalid content sniffer type was requested + MOZ_ASSERT(false); + return; + } + + // In case XCTO nosniff was present, we could just skip sniffing here + nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest); + if (channel) { + nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo(); + if (loadInfo->GetSkipContentSniffing()) { + /* Bug 1571742 + * We cannot skip snffing if the current MIME-Type might be a JSON. + * The JSON-Viewer relies on its own sniffer to determine, if it can + * render the page, so we need to make an exception if the Server provides + * a application/ mime, as it might be json. + */ + nsAutoCString currentContentType; + channel->GetContentType(currentContentType); + if (!StringBeginsWith(currentContentType, "application/"_ns)) { + return; + } + } + } + nsCOMArray<nsIContentSniffer> sniffers; + cache->GetEntries(sniffers); + for (int32_t i = 0; i < sniffers.Count(); ++i) { + nsresult rv = sniffers[i]->GetMIMETypeFromContent(aRequest, aData, aLength, + aSniffedType); + if (NS_SUCCEEDED(rv) && !aSniffedType.IsEmpty()) { + return; + } + } + + aSniffedType.Truncate(); +} + +bool NS_IsSrcdocChannel(nsIChannel* aChannel) { + bool isSrcdoc; + nsCOMPtr<nsIInputStreamChannel> isr = do_QueryInterface(aChannel); + if (isr) { + isr->GetIsSrcdocChannel(&isSrcdoc); + return isSrcdoc; + } + nsCOMPtr<nsIViewSourceChannel> vsc = do_QueryInterface(aChannel); + if (vsc) { + nsresult rv = vsc->GetIsSrcdocChannel(&isSrcdoc); + if (NS_SUCCEEDED(rv)) { + return isSrcdoc; + } + } + return false; +} + +nsresult NS_ShouldSecureUpgrade( + nsIURI* aURI, nsILoadInfo* aLoadInfo, nsIPrincipal* aChannelResultPrincipal, + bool aPrivateBrowsing, bool aAllowSTS, + const OriginAttributes& aOriginAttributes, bool& aShouldUpgrade, + std::function<void(bool, nsresult)>&& aResultCallback, + bool& aWillCallback) { + aWillCallback = false; + + // 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 isHttps = aURI->SchemeIs("https"); + + if (!isHttps && + !nsMixedContentBlocker::IsPotentiallyTrustworthyLoopbackURL(aURI)) { + if (aLoadInfo) { + // Check if the request can get upgraded with the HTTPS-Only mode + if (nsHTTPSOnlyUtils::ShouldUpgradeRequest(aURI, aLoadInfo)) { + aShouldUpgrade = true; + return NS_OK; + } + + // If any of the documents up the chain to the root document makes use of + // the CSP directive 'upgrade-insecure-requests', then it's time to + // fulfill the promise to CSP and mixed content blocking to upgrade the + // channel from http to https. + if (aLoadInfo->GetUpgradeInsecureRequests() || + aLoadInfo->GetBrowserUpgradeInsecureRequests()) { + // let's log a message to the console that we are upgrading a request + nsAutoCString scheme; + aURI->GetScheme(scheme); + // append the additional 's' for security to the scheme :-) + scheme.AppendLiteral("s"); + NS_ConvertUTF8toUTF16 reportSpec(aURI->GetSpecOrDefault()); + NS_ConvertUTF8toUTF16 reportScheme(scheme); + + if (aLoadInfo->GetUpgradeInsecureRequests()) { + AutoTArray<nsString, 2> params = {reportSpec, reportScheme}; + uint32_t innerWindowId = aLoadInfo->GetInnerWindowID(); + CSP_LogLocalizedStr( + "upgradeInsecureRequest", params, + u""_ns, // aSourceFile + u""_ns, // aScriptSample + 0, // aLineNumber + 0, // aColumnNumber + nsIScriptError::warningFlag, "upgradeInsecureRequest"_ns, + innerWindowId, + !!aLoadInfo->GetOriginAttributes().mPrivateBrowsingId); + Telemetry::AccumulateCategorical( + Telemetry::LABELS_HTTP_SCHEME_UPGRADE_TYPE::CSP); + } else { + AutoTArray<nsString, 2> params = {reportSpec, reportScheme}; + + nsAutoString localizedMsg; + nsContentUtils::FormatLocalizedString( + nsContentUtils::eSECURITY_PROPERTIES, "MixedContentAutoUpgrade", + params, localizedMsg); + + // Prepending ixed Content to the outgoing console message + nsString message; + message.AppendLiteral(u"Mixed Content: "); + message.Append(localizedMsg); + + uint32_t innerWindowId = aLoadInfo->GetInnerWindowID(); + nsContentUtils::ReportToConsoleByWindowID( + message, nsIScriptError::warningFlag, "Mixed Content Message"_ns, + innerWindowId, aURI); + + // Set this flag so we know we'll upgrade because of + // 'security.mixed_content.upgrade_display_content'. + aLoadInfo->SetBrowserDidUpgradeInsecureRequests(true); + Telemetry::AccumulateCategorical( + Telemetry::LABELS_HTTP_SCHEME_UPGRADE_TYPE::BrowserDisplay); + } + + aShouldUpgrade = true; + return NS_OK; + } + } + + // enforce Strict-Transport-Security + nsISiteSecurityService* sss = gHttpHandler->GetSSService(); + NS_ENSURE_TRUE(sss, NS_ERROR_OUT_OF_MEMORY); + + bool isStsHost = false; + uint32_t hstsSource = 0; + uint32_t flags = + aPrivateBrowsing ? nsISocketProvider::NO_PERMANENT_STORAGE : 0; + + auto handleResultFunc = [aAllowSTS](bool aIsStsHost, uint32_t aHstsSource) { + if (aIsStsHost) { + LOG(("nsHttpChannel::Connect() STS permissions found\n")); + if (aAllowSTS) { + Telemetry::AccumulateCategorical( + Telemetry::LABELS_HTTP_SCHEME_UPGRADE_TYPE::STS); + switch (aHstsSource) { + case nsISiteSecurityService::SOURCE_PRELOAD_LIST: + Telemetry::Accumulate(Telemetry::HSTS_UPGRADE_SOURCE, 0); + break; + case nsISiteSecurityService::SOURCE_ORGANIC_REQUEST: + Telemetry::Accumulate(Telemetry::HSTS_UPGRADE_SOURCE, 1); + break; + case nsISiteSecurityService::SOURCE_UNKNOWN: + default: + // record this as an organic request + Telemetry::Accumulate(Telemetry::HSTS_UPGRADE_SOURCE, 1); + break; + } + return true; + } + Telemetry::AccumulateCategorical( + Telemetry::LABELS_HTTP_SCHEME_UPGRADE_TYPE::PrefBlockedSTS); + } else { + Telemetry::AccumulateCategorical( + Telemetry::LABELS_HTTP_SCHEME_UPGRADE_TYPE::NoReasonToUpgrade); + } + return false; + }; + + // Calling |IsSecureURI| before the storage is ready to read will + // block the main thread. Once the storage is ready, we can call it + // from main thread. + static Atomic<bool, Relaxed> storageReady(false); + if (!storageReady && gSocketTransportService && aResultCallback) { + nsCOMPtr<nsIURI> uri = aURI; + nsCOMPtr<nsISiteSecurityService> service = sss; + nsresult rv = gSocketTransportService->Dispatch( + NS_NewRunnableFunction( + "net::NS_ShouldSecureUpgrade", + [service{std::move(service)}, uri{std::move(uri)}, flags(flags), + originAttributes(aOriginAttributes), + handleResultFunc{std::move(handleResultFunc)}, + resultCallback{std::move(aResultCallback)}]() mutable { + uint32_t hstsSource = 0; + bool isStsHost = false; + nsresult rv = service->IsSecureURI( + nsISiteSecurityService::HEADER_HSTS, uri, flags, + originAttributes, nullptr, &hstsSource, &isStsHost); + + // Successfully get the result from |IsSecureURI| implies that + // the storage is ready to read. + storageReady = NS_SUCCEEDED(rv); + bool shouldUpgrade = handleResultFunc(isStsHost, hstsSource); + + NS_DispatchToMainThread(NS_NewRunnableFunction( + "net::NS_ShouldSecureUpgrade::ResultCallback", + [rv, shouldUpgrade, + resultCallback{std::move(resultCallback)}]() { + resultCallback(shouldUpgrade, rv); + })); + }), + NS_DISPATCH_NORMAL); + aWillCallback = NS_SUCCEEDED(rv); + return rv; + } + + nsresult rv = + sss->IsSecureURI(nsISiteSecurityService::HEADER_HSTS, aURI, flags, + aOriginAttributes, nullptr, &hstsSource, &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); + + aShouldUpgrade = handleResultFunc(isStsHost, hstsSource); + return NS_OK; + } + + Telemetry::AccumulateCategorical( + Telemetry::LABELS_HTTP_SCHEME_UPGRADE_TYPE::AlreadyHTTPS); + aShouldUpgrade = false; + return NS_OK; +} + +nsresult NS_GetSecureUpgradedURI(nsIURI* aURI, nsIURI** aUpgradedURI) { + NS_MutateURI mutator(aURI); + mutator.SetScheme("https"_ns); // Change the scheme to HTTPS: + + // Change the default port to 443: + nsCOMPtr<nsIStandardURL> stdURL = do_QueryInterface(aURI); + if (stdURL) { + mutator.Apply( + NS_MutatorMethod(&nsIStandardURLMutator::SetDefaultPort, 443, nullptr)); + } else { + // If we don't have a nsStandardURL, fall back to using GetPort/SetPort. + // XXXdholbert Is this function even called with a non-nsStandardURL arg, + // in practice? + NS_WARNING("Calling NS_GetSecureUpgradedURI for non nsStandardURL"); + int32_t oldPort = -1; + nsresult rv = aURI->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) { + mutator.SetPort(-1); + } else { + mutator.SetPort(oldPort); + } + } + + return mutator.Finalize(aUpgradedURI); +} + +nsresult NS_CompareLoadInfoAndLoadContext(nsIChannel* aChannel) { + nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo(); + + nsCOMPtr<nsILoadContext> loadContext; + NS_QueryNotificationCallbacks(aChannel, loadContext); + if (!loadContext) { + return NS_OK; + } + + // We try to skip about:newtab. + // about:newtab will use SystemPrincipal to download thumbnails through + // https:// and blob URLs. + bool isAboutPage = false; + nsINode* node = loadInfo->LoadingNode(); + if (node) { + nsIURI* uri = node->OwnerDoc()->GetDocumentURI(); + isAboutPage = uri->SchemeIs("about"); + } + + if (isAboutPage) { + return NS_OK; + } + + // We skip the favicon loading here. The favicon loading might be + // triggered by the XUL image. For that case, the loadContext will have + // default originAttributes since the XUL image uses SystemPrincipal, but + // the loadInfo will use originAttributes from the content. Thus, the + // originAttributes between loadInfo and loadContext will be different. + // That's why we have to skip the comparison for the favicon loading. + if (loadInfo->GetLoadingPrincipal() && + loadInfo->GetLoadingPrincipal()->IsSystemPrincipal() && + loadInfo->InternalContentPolicyType() == + nsIContentPolicy::TYPE_INTERNAL_IMAGE_FAVICON) { + return NS_OK; + } + + OriginAttributes originAttrsLoadInfo = loadInfo->GetOriginAttributes(); + OriginAttributes originAttrsLoadContext; + loadContext->GetOriginAttributes(originAttrsLoadContext); + + LOG( + ("NS_CompareLoadInfoAndLoadContext - loadInfo: %d, %d; " + "loadContext: %d, %d. [channel=%p]", + originAttrsLoadInfo.mUserContextId, + originAttrsLoadInfo.mPrivateBrowsingId, + originAttrsLoadContext.mUserContextId, + originAttrsLoadContext.mPrivateBrowsingId, aChannel)); + + MOZ_ASSERT(originAttrsLoadInfo.mUserContextId == + originAttrsLoadContext.mUserContextId, + "The value of mUserContextId in the loadContext and in the " + "loadInfo are not the same!"); + + MOZ_ASSERT(originAttrsLoadInfo.mPrivateBrowsingId == + originAttrsLoadContext.mPrivateBrowsingId, + "The value of mPrivateBrowsingId in the loadContext and in the " + "loadInfo are not the same!"); + + return NS_OK; +} + +nsresult NS_SetRequestBlockingReason(nsIChannel* channel, uint32_t reason) { + NS_ENSURE_ARG(channel); + + nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo(); + return NS_SetRequestBlockingReason(loadInfo, reason); +} + +nsresult NS_SetRequestBlockingReason(nsILoadInfo* loadInfo, uint32_t reason) { + NS_ENSURE_ARG(loadInfo); + + return loadInfo->SetRequestBlockingReason(reason); +} + +nsresult NS_SetRequestBlockingReasonIfNull(nsILoadInfo* loadInfo, + uint32_t reason) { + NS_ENSURE_ARG(loadInfo); + + uint32_t existingReason; + if (NS_SUCCEEDED(loadInfo->GetRequestBlockingReason(&existingReason)) && + existingReason != nsILoadInfo::BLOCKING_REASON_NONE) { + return NS_OK; + } + + return loadInfo->SetRequestBlockingReason(reason); +} + +bool NS_IsOffline() { + bool offline = true; + bool connectivity = true; + nsCOMPtr<nsIIOService> ios = do_GetIOService(); + if (ios) { + ios->GetOffline(&offline); + ios->GetConnectivity(&connectivity); + } + return offline || !connectivity; +} + +/** + * This function returns true if this channel should be classified by + * the URL Classifier, false otherwise. + * + * The idea of the algorithm to determine if a channel should be + * classified is based on: + * 1. Channels created by non-privileged code should be classified. + * 2. Top-level document’s channels, if loaded by privileged code + * (system principal), should be classified. + * 3. Any other channel, created by privileged code, is considered safe. + * + * A bad/hacked/corrupted safebrowsing database, plus a mistakenly + * classified critical channel (this may result from a bug in the exemption + * rules or incorrect information being passed into) can cause serious + * problems. For example, if the updater channel is classified and blocked + * by the Safe Browsing, Firefox can't update itself, and there is no way to + * recover from that. + * + * So two safeguards are added to ensure critical channels are never + * automatically classified either because there is a bug in the algorithm + * or the data in loadinfo is wrong. + * 1. beConservative, this is set by ServiceRequest and we treat + * channel created for ServiceRequest as critical channels. + * 2. nsIChannel::LOAD_BYPASS_URL_CLASSIFIER, channel's opener can use this + * flag to enforce bypassing the URL classifier check. + */ +bool NS_ShouldClassifyChannel(nsIChannel* aChannel) { + nsLoadFlags loadFlags; + Unused << aChannel->GetLoadFlags(&loadFlags); + // If our load flags dictate that we must let this channel through without + // URL classification, obey that here without performing more checks. + if (loadFlags & nsIChannel::LOAD_BYPASS_URL_CLASSIFIER) { + return false; + } + + nsCOMPtr<nsIHttpChannelInternal> httpChannel(do_QueryInterface(aChannel)); + if (httpChannel) { + bool beConservative; + nsresult rv = httpChannel->GetBeConservative(&beConservative); + + // beConservative flag, set by ServiceRequest to ensure channels that + // fetch update use conservative TLS setting, are used here to identify + // channels are critical to bypass classification. for channels don't + // support beConservative, continue to apply the exemption rules. + if (NS_SUCCEEDED(rv) && beConservative) { + return false; + } + } + + nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo(); + ExtContentPolicyType type = loadInfo->GetExternalContentPolicyType(); + // Skip classifying channel triggered by system unless it is a top-level + // load. + if (loadInfo->TriggeringPrincipal()->IsSystemPrincipal() && + ExtContentPolicy::TYPE_DOCUMENT != type) { + return false; + } + + return true; +} + +namespace mozilla { +namespace net { + +bool InScriptableRange(int64_t val) { + return (val <= kJS_MAX_SAFE_INTEGER) && (val >= kJS_MIN_SAFE_INTEGER); +} + +bool InScriptableRange(uint64_t val) { return val <= kJS_MAX_SAFE_UINTEGER; } + +nsresult GetParameterHTTP(const nsACString& aHeaderVal, const char* aParamName, + nsAString& aResult) { + return nsMIMEHeaderParamImpl::GetParameterHTTP(aHeaderVal, aParamName, + aResult); +} + +bool ChannelIsPost(nsIChannel* aChannel) { + if (nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aChannel)) { + nsAutoCString method; + Unused << httpChannel->GetRequestMethod(method); + return method.EqualsLiteral("POST"); + } + return false; +} + +bool SchemeIsHTTP(nsIURI* aURI) { + MOZ_ASSERT(aURI); + return aURI->SchemeIs("http"); +} + +bool SchemeIsHTTPS(nsIURI* aURI) { + MOZ_ASSERT(aURI); + return aURI->SchemeIs("https"); +} + +bool SchemeIsJavascript(nsIURI* aURI) { + MOZ_ASSERT(aURI); + return aURI->SchemeIs("javascript"); +} + +bool SchemeIsChrome(nsIURI* aURI) { + MOZ_ASSERT(aURI); + return aURI->SchemeIs("chrome"); +} + +bool SchemeIsAbout(nsIURI* aURI) { + MOZ_ASSERT(aURI); + return aURI->SchemeIs("about"); +} + +bool SchemeIsBlob(nsIURI* aURI) { + MOZ_ASSERT(aURI); + return aURI->SchemeIs("blob"); +} + +bool SchemeIsFile(nsIURI* aURI) { + MOZ_ASSERT(aURI); + return aURI->SchemeIs("file"); +} + +bool SchemeIsData(nsIURI* aURI) { + MOZ_ASSERT(aURI); + return aURI->SchemeIs("data"); +} + +bool SchemeIsViewSource(nsIURI* aURI) { + MOZ_ASSERT(aURI); + return aURI->SchemeIs("view-source"); +} + +bool SchemeIsResource(nsIURI* aURI) { + MOZ_ASSERT(aURI); + return aURI->SchemeIs("resource"); +} + +bool SchemeIsFTP(nsIURI* aURI) { + MOZ_ASSERT(aURI); + return aURI->SchemeIs("ftp"); +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/nsNetUtil.h b/netwerk/base/nsNetUtil.h new file mode 100644 index 0000000000..39e3d6f4bd --- /dev/null +++ b/netwerk/base/nsNetUtil.h @@ -0,0 +1,984 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=4 sw=2 sts=2 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/. */ + +#ifndef nsNetUtil_h__ +#define nsNetUtil_h__ + +#include <functional> +#include "mozilla/Maybe.h" +#include "mozilla/ResultExtensions.h" +#include "nsCOMPtr.h" +#include "nsIInterfaceRequestor.h" +#include "nsIInterfaceRequestorUtils.h" +#include "nsILoadGroup.h" +#include "nsINestedURI.h" +#include "nsINetUtil.h" +#include "nsIRequest.h" +#include "nsILoadInfo.h" +#include "nsIIOService.h" +#include "nsIURI.h" +#include "mozilla/NotNull.h" +#include "mozilla/Services.h" +#include "mozilla/Unused.h" +#include "nsNetCID.h" +#include "nsReadableUtils.h" +#include "nsServiceManagerUtils.h" +#include "nsString.h" + +class nsIPrincipal; +class nsIAsyncStreamCopier; +class nsIAuthPrompt; +class nsIAuthPrompt2; +class nsIChannel; +class nsIChannelPolicy; +class nsICookieJarSettings; +class nsIDownloadObserver; +class nsIEventTarget; +class nsIFileProtocolHandler; +class nsIFileStream; +class nsIHttpChannel; +class nsIInputStream; +class nsIInputStreamPump; +class nsIInterfaceRequestor; +class nsIOutputStream; +class nsIParentChannel; +class nsIPersistentProperties; +class nsIProxyInfo; +class nsIRequestObserver; +class nsIStreamListener; +class nsIStreamLoader; +class nsIStreamLoaderObserver; +class nsIIncrementalStreamLoader; +class nsIIncrementalStreamLoaderObserver; + +namespace mozilla { +class Encoding; +class OriginAttributes; +namespace dom { +class ClientInfo; +class PerformanceStorage; +class ServiceWorkerDescriptor; +} // namespace dom + +namespace ipc { +class FileDescriptor; +} // namespace ipc + +} // namespace mozilla + +template <class> +class nsCOMPtr; +template <typename> +struct already_AddRefed; + +already_AddRefed<nsIIOService> do_GetIOService(nsresult* error = nullptr); + +already_AddRefed<nsINetUtil> do_GetNetUtil(nsresult* error = nullptr); + +// private little helper function... don't call this directly! +nsresult net_EnsureIOService(nsIIOService** ios, nsCOMPtr<nsIIOService>& grip); + +nsresult NS_NewURI(nsIURI** result, const nsACString& spec, + const char* charset = nullptr, nsIURI* baseURI = nullptr); + +nsresult NS_NewURI(nsIURI** result, const nsACString& spec, + mozilla::NotNull<const mozilla::Encoding*> encoding, + nsIURI* baseURI = nullptr); + +nsresult NS_NewURI(nsIURI** result, const nsAString& spec, + const char* charset = nullptr, nsIURI* baseURI = nullptr); + +nsresult NS_NewURI(nsIURI** result, const nsAString& spec, + mozilla::NotNull<const mozilla::Encoding*> encoding, + nsIURI* baseURI = nullptr); + +nsresult NS_NewURI(nsIURI** result, const char* spec, + nsIURI* baseURI = nullptr); + +nsresult NS_NewFileURI( + nsIURI** result, nsIFile* spec, + nsIIOService* ioService = + nullptr); // pass in nsIIOService to optimize callers + +// These methods will only mutate the URI if the ref of aInput doesn't already +// match the ref we are trying to set. +// If aInput has no ref, and we are calling NS_GetURIWithoutRef, or +// NS_GetURIWithNewRef with an empty string, then aOutput will be the same +// as aInput. The same is true if aRef is already equal to the ref of aInput. +// This is OK because URIs are immutable and threadsafe. +// If the URI doesn't support ref fragments aOutput will be the same as aInput. +nsresult NS_GetURIWithNewRef(nsIURI* aInput, const nsACString& aRef, + nsIURI** aOutput); +nsresult NS_GetURIWithoutRef(nsIURI* aInput, nsIURI** aOutput); + +nsresult NS_GetSanitizedURIStringFromURI(nsIURI* aUri, + nsAString& aSanitizedSpec); + +/* + * How to create a new Channel, using NS_NewChannel, + * NS_NewChannelWithTriggeringPrincipal, + * NS_NewInputStreamChannel, NS_NewChannelInternal + * and it's variations: + * + * What specific API function to use: + * * The NS_NewChannelInternal functions should almost never be directly + * called outside of necko code. + * * If possible, use NS_NewChannel() providing a loading *nsINode* + * * If no loading *nsINode* is available, try calling NS_NewChannel() providing + * a loading *ClientInfo*. + * * If no loading *nsINode* or *ClientInfo* are available, call NS_NewChannel() + * providing a loading *nsIPrincipal*. + * * Call NS_NewChannelWithTriggeringPrincipal if the triggeringPrincipal + * is different from the loadingPrincipal. + * * Call NS_NewChannelInternal() providing aLoadInfo object in cases where + * you already have loadInfo object, e.g in case of a channel redirect. + * + * @param aURI + * nsIURI from which to make a channel + * @param aLoadingNode + * @param aLoadingPrincipal + * @param aTriggeringPrincipal + * @param aSecurityFlags + * @param aContentPolicyType + * These will be used as values for the nsILoadInfo object on the + * created channel. For details, see nsILoadInfo in nsILoadInfo.idl + * + * Please note, if you provide both a loadingNode and a loadingPrincipal, + * then loadingPrincipal must be equal to loadingNode->NodePrincipal(). + * But less error prone is to just supply a loadingNode. + * + * Note, if you provide a loading ClientInfo its principal must match the + * loading principal. Currently you must pass both as the loading principal + * may have additional mutable values like CSP on it. In the future these + * will be removed from nsIPrincipal and the API can be changed to take just + * the loading ClientInfo. + * + * Keep in mind that URIs coming from a webpage should *never* use the + * systemPrincipal as the loadingPrincipal. + */ +nsresult NS_NewChannelInternal( + nsIChannel** outChannel, nsIURI* aUri, nsINode* aLoadingNode, + nsIPrincipal* aLoadingPrincipal, nsIPrincipal* aTriggeringPrincipal, + const mozilla::Maybe<mozilla::dom::ClientInfo>& aLoadingClientInfo, + const mozilla::Maybe<mozilla::dom::ServiceWorkerDescriptor>& aController, + nsSecurityFlags aSecurityFlags, nsContentPolicyType aContentPolicyType, + nsICookieJarSettings* aCookieJarSettings = nullptr, + mozilla::dom::PerformanceStorage* aPerformanceStorage = nullptr, + nsILoadGroup* aLoadGroup = nullptr, + nsIInterfaceRequestor* aCallbacks = nullptr, + nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL, + nsIIOService* aIoService = nullptr, uint32_t aSandboxFlags = 0); + +// See NS_NewChannelInternal for usage and argument description +nsresult NS_NewChannelInternal( + nsIChannel** outChannel, nsIURI* aUri, nsILoadInfo* aLoadInfo, + mozilla::dom::PerformanceStorage* aPerformanceStorage = nullptr, + nsILoadGroup* aLoadGroup = nullptr, + nsIInterfaceRequestor* aCallbacks = nullptr, + nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL, + nsIIOService* aIoService = nullptr); + +// See NS_NewChannelInternal for usage and argument description +nsresult /*NS_NewChannelWithNodeAndTriggeringPrincipal */ +NS_NewChannelWithTriggeringPrincipal( + nsIChannel** outChannel, nsIURI* aUri, nsINode* aLoadingNode, + nsIPrincipal* aTriggeringPrincipal, nsSecurityFlags aSecurityFlags, + nsContentPolicyType aContentPolicyType, + mozilla::dom::PerformanceStorage* aPerformanceStorage = nullptr, + nsILoadGroup* aLoadGroup = nullptr, + nsIInterfaceRequestor* aCallbacks = nullptr, + nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL, + nsIIOService* aIoService = nullptr); + +// See NS_NewChannelInternal for usage and argument description +nsresult NS_NewChannelWithTriggeringPrincipal( + nsIChannel** outChannel, nsIURI* aUri, nsIPrincipal* aLoadingPrincipal, + nsIPrincipal* aTriggeringPrincipal, nsSecurityFlags aSecurityFlags, + nsContentPolicyType aContentPolicyType, + nsICookieJarSettings* aCookieJarSettings = nullptr, + mozilla::dom::PerformanceStorage* aPerformanceStorage = nullptr, + nsILoadGroup* aLoadGroup = nullptr, + nsIInterfaceRequestor* aCallbacks = nullptr, + nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL, + nsIIOService* aIoService = nullptr); + +// See NS_NewChannelInternal for usage and argument description +nsresult NS_NewChannelWithTriggeringPrincipal( + nsIChannel** outChannel, nsIURI* aUri, nsIPrincipal* aLoadingPrincipal, + nsIPrincipal* aTriggeringPrincipal, + const mozilla::dom::ClientInfo& aLoadingClientInfo, + const mozilla::Maybe<mozilla::dom::ServiceWorkerDescriptor>& aController, + nsSecurityFlags aSecurityFlags, nsContentPolicyType aContentPolicyType, + nsICookieJarSettings* aCookieJarSettings = nullptr, + mozilla::dom::PerformanceStorage* aPerformanceStorage = nullptr, + nsILoadGroup* aLoadGroup = nullptr, + nsIInterfaceRequestor* aCallbacks = nullptr, + nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL, + nsIIOService* aIoService = nullptr); + +// See NS_NewChannelInternal for usage and argument description +nsresult NS_NewChannel( + nsIChannel** outChannel, nsIURI* aUri, nsINode* aLoadingNode, + nsSecurityFlags aSecurityFlags, nsContentPolicyType aContentPolicyType, + mozilla::dom::PerformanceStorage* aPerformanceStorage = nullptr, + nsILoadGroup* aLoadGroup = nullptr, + nsIInterfaceRequestor* aCallbacks = nullptr, + nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL, + nsIIOService* aIoService = nullptr, uint32_t aSandboxFlags = 0); + +// See NS_NewChannelInternal for usage and argument description +nsresult NS_NewChannel( + nsIChannel** outChannel, nsIURI* aUri, nsIPrincipal* aLoadingPrincipal, + nsSecurityFlags aSecurityFlags, nsContentPolicyType aContentPolicyType, + nsICookieJarSettings* aCookieJarSettings = nullptr, + mozilla::dom::PerformanceStorage* aPerformanceStorage = nullptr, + nsILoadGroup* aLoadGroup = nullptr, + nsIInterfaceRequestor* aCallbacks = nullptr, + nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL, + nsIIOService* aIoService = nullptr, uint32_t aSandboxFlags = 0); + +// See NS_NewChannelInternal for usage and argument description +nsresult NS_NewChannel( + nsIChannel** outChannel, nsIURI* aUri, nsIPrincipal* aLoadingPrincipal, + const mozilla::dom::ClientInfo& aLoadingClientInfo, + const mozilla::Maybe<mozilla::dom::ServiceWorkerDescriptor>& aController, + nsSecurityFlags aSecurityFlags, nsContentPolicyType aContentPolicyType, + nsICookieJarSettings* aCookieJarSettings = nullptr, + mozilla::dom::PerformanceStorage* aPerformanceStorage = nullptr, + nsILoadGroup* aLoadGroup = nullptr, + nsIInterfaceRequestor* aCallbacks = nullptr, + nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL, + nsIIOService* aIoService = nullptr, uint32_t aSandboxFlags = 0); + +nsresult NS_GetIsDocumentChannel(nsIChannel* aChannel, bool* aIsDocument); + +nsresult NS_MakeAbsoluteURI(nsACString& result, const nsACString& spec, + nsIURI* baseURI); + +nsresult NS_MakeAbsoluteURI(char** result, const char* spec, nsIURI* baseURI); + +nsresult NS_MakeAbsoluteURI(nsAString& result, const nsAString& spec, + nsIURI* baseURI); + +/** + * This function is a helper function to get a scheme's default port. + */ +int32_t NS_GetDefaultPort(const char* scheme, + nsIIOService* ioService = nullptr); + +/** + * This function is a helper function to apply the ToAscii conversion + * to a string + */ +bool NS_StringToACE(const nsACString& idn, nsACString& result); + +/** + * This function is a helper function to get a protocol's default port if the + * URI does not specify a port explicitly. Returns -1 if this protocol has no + * concept of ports or if there was an error getting the port. + */ +int32_t NS_GetRealPort(nsIURI* aURI); + +nsresult NS_NewInputStreamChannelInternal( + nsIChannel** outChannel, nsIURI* aUri, + already_AddRefed<nsIInputStream> aStream, const nsACString& aContentType, + const nsACString& aContentCharset, nsILoadInfo* aLoadInfo); + +nsresult NS_NewInputStreamChannelInternal( + nsIChannel** outChannel, nsIURI* aUri, + already_AddRefed<nsIInputStream> aStream, const nsACString& aContentType, + const nsACString& aContentCharset, nsINode* aLoadingNode, + nsIPrincipal* aLoadingPrincipal, nsIPrincipal* aTriggeringPrincipal, + nsSecurityFlags aSecurityFlags, nsContentPolicyType aContentPolicyType); + +nsresult NS_NewInputStreamChannel(nsIChannel** outChannel, nsIURI* aUri, + already_AddRefed<nsIInputStream> aStream, + nsIPrincipal* aLoadingPrincipal, + nsSecurityFlags aSecurityFlags, + nsContentPolicyType aContentPolicyType, + const nsACString& aContentType = ""_ns, + const nsACString& aContentCharset = ""_ns); + +nsresult NS_NewInputStreamChannelInternal( + nsIChannel** outChannel, nsIURI* aUri, const nsAString& aData, + const nsACString& aContentType, nsINode* aLoadingNode, + nsIPrincipal* aLoadingPrincipal, nsIPrincipal* aTriggeringPrincipal, + nsSecurityFlags aSecurityFlags, nsContentPolicyType aContentPolicyType, + bool aIsSrcdocChannel = false); + +nsresult NS_NewInputStreamChannelInternal(nsIChannel** outChannel, nsIURI* aUri, + const nsAString& aData, + const nsACString& aContentType, + nsILoadInfo* aLoadInfo, + bool aIsSrcdocChannel = false); + +nsresult NS_NewInputStreamChannel(nsIChannel** outChannel, nsIURI* aUri, + const nsAString& aData, + const nsACString& aContentType, + nsIPrincipal* aLoadingPrincipal, + nsSecurityFlags aSecurityFlags, + nsContentPolicyType aContentPolicyType, + bool aIsSrcdocChannel = false); + +nsresult NS_NewInputStreamPump(nsIInputStreamPump** aResult, + already_AddRefed<nsIInputStream> aStream, + uint32_t aSegsize = 0, uint32_t aSegcount = 0, + bool aCloseWhenDone = false, + nsIEventTarget* aMainThreadTarget = nullptr); + +nsresult NS_NewLoadGroup(nsILoadGroup** result, nsIRequestObserver* obs); + +// Create a new nsILoadGroup that will match the given principal. +nsresult NS_NewLoadGroup(nsILoadGroup** aResult, nsIPrincipal* aPrincipal); + +// Determine if the given loadGroup/principal pair will produce a principal +// with similar permissions when passed to NS_NewChannel(). This checks for +// things like making sure the browser element flag matches. Without +// an appropriate load group these values can be lost when getting the result +// principal back out of the channel. Null principals are also always allowed +// as they do not have permissions to actually use the load group. +bool NS_LoadGroupMatchesPrincipal(nsILoadGroup* aLoadGroup, + nsIPrincipal* aPrincipal); + +nsresult NS_NewDownloader(nsIStreamListener** result, + nsIDownloadObserver* observer, + nsIFile* downloadLocation = nullptr); + +nsresult NS_NewStreamLoader(nsIStreamLoader** result, + nsIStreamLoaderObserver* observer, + nsIRequestObserver* requestObserver = nullptr); + +nsresult NS_NewIncrementalStreamLoader( + nsIIncrementalStreamLoader** result, + nsIIncrementalStreamLoaderObserver* observer); + +nsresult NS_NewStreamLoaderInternal( + nsIStreamLoader** outStream, nsIURI* aUri, + nsIStreamLoaderObserver* aObserver, nsINode* aLoadingNode, + nsIPrincipal* aLoadingPrincipal, nsSecurityFlags aSecurityFlags, + nsContentPolicyType aContentPolicyType, nsILoadGroup* aLoadGroup = nullptr, + nsIInterfaceRequestor* aCallbacks = nullptr, + nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL); + +nsresult NS_NewStreamLoader(nsIStreamLoader** outStream, nsIURI* aUri, + nsIStreamLoaderObserver* aObserver, + nsINode* aLoadingNode, + nsSecurityFlags aSecurityFlags, + nsContentPolicyType aContentPolicyType, + nsILoadGroup* aLoadGroup = nullptr, + nsIInterfaceRequestor* aCallbacks = nullptr, + nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL); + +nsresult NS_NewStreamLoader(nsIStreamLoader** outStream, nsIURI* aUri, + nsIStreamLoaderObserver* aObserver, + nsIPrincipal* aLoadingPrincipal, + nsSecurityFlags aSecurityFlags, + nsContentPolicyType aContentPolicyType, + nsILoadGroup* aLoadGroup = nullptr, + nsIInterfaceRequestor* aCallbacks = nullptr, + nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL); + +nsresult NS_NewSyncStreamListener(nsIStreamListener** result, + nsIInputStream** stream); + +/** + * Implement the nsIChannel::Open(nsIInputStream**) method using the channel's + * AsyncOpen method. + * + * NOTE: Reading from the returned nsIInputStream may spin the current + * thread's event queue, which could result in any event being processed. + */ +nsresult NS_ImplementChannelOpen(nsIChannel* channel, nsIInputStream** result); + +nsresult NS_NewRequestObserverProxy(nsIRequestObserver** result, + nsIRequestObserver* observer, + nsISupports* context); + +nsresult NS_NewSimpleStreamListener(nsIStreamListener** result, + nsIOutputStream* sink, + nsIRequestObserver* observer = nullptr); + +nsresult NS_CheckPortSafety(int32_t port, const char* scheme, + nsIIOService* ioService = nullptr); + +// Determine if this URI is using a safe port. +nsresult NS_CheckPortSafety(nsIURI* uri); + +nsresult NS_NewProxyInfo(const nsACString& type, const nsACString& host, + int32_t port, uint32_t flags, nsIProxyInfo** result); + +nsresult NS_GetFileProtocolHandler(nsIFileProtocolHandler** result, + nsIIOService* ioService = nullptr); + +nsresult NS_GetFileFromURLSpec(const nsACString& inURL, nsIFile** result, + nsIIOService* ioService = nullptr); + +nsresult NS_GetURLSpecFromFile(nsIFile* file, nsACString& url, + nsIIOService* ioService = nullptr); + +/** + * Converts the nsIFile to the corresponding URL string. + * Should only be called on files which are not directories, + * is otherwise identical to NS_GetURLSpecFromFile, but is + * usually more efficient. + * Warning: this restriction may not be enforced at runtime! + */ +nsresult NS_GetURLSpecFromActualFile(nsIFile* file, nsACString& url, + nsIIOService* ioService = nullptr); + +/** + * Converts the nsIFile to the corresponding URL string. + * Should only be called on files which are directories, + * is otherwise identical to NS_GetURLSpecFromFile, but is + * usually more efficient. + * Warning: this restriction may not be enforced at runtime! + */ +nsresult NS_GetURLSpecFromDir(nsIFile* file, nsACString& url, + nsIIOService* ioService = nullptr); + +/** + * Obtains the referrer for a given channel. This first tries to obtain the + * referrer from the property docshell.internalReferrer, and if that doesn't + * work and the channel is an nsIHTTPChannel, we check it's referrer property. + * + */ +void NS_GetReferrerFromChannel(nsIChannel* channel, nsIURI** referrer); + +nsresult NS_ParseRequestContentType(const nsACString& rawContentType, + nsCString& contentType, + nsCString& contentCharset); + +nsresult NS_ParseResponseContentType(const nsACString& rawContentType, + nsCString& contentType, + nsCString& contentCharset); + +nsresult NS_ExtractCharsetFromContentType(const nsACString& rawContentType, + nsCString& contentCharset, + bool* hadCharset, + int32_t* charsetStart, + int32_t* charsetEnd); + +nsresult NS_NewLocalFileInputStream(nsIInputStream** result, nsIFile* file, + int32_t ioFlags = -1, int32_t perm = -1, + int32_t behaviorFlags = 0); + +mozilla::Result<nsCOMPtr<nsIInputStream>, nsresult> NS_NewLocalFileInputStream( + nsIFile* file, int32_t ioFlags = -1, int32_t perm = -1, + int32_t behaviorFlags = 0); + +nsresult NS_NewLocalFileOutputStream(nsIOutputStream** result, nsIFile* file, + int32_t ioFlags = -1, int32_t perm = -1, + int32_t behaviorFlags = 0); + +mozilla::Result<nsCOMPtr<nsIOutputStream>, nsresult> +NS_NewLocalFileOutputStream(nsIFile* file, int32_t ioFlags = -1, + int32_t perm = -1, int32_t behaviorFlags = 0); + +nsresult NS_NewLocalFileOutputStream(nsIOutputStream** result, + const mozilla::ipc::FileDescriptor& fd); + +// returns a file output stream which can be QI'ed to nsISafeOutputStream. +nsresult NS_NewAtomicFileOutputStream(nsIOutputStream** result, nsIFile* file, + int32_t ioFlags = -1, int32_t perm = -1, + int32_t behaviorFlags = 0); + +// returns a file output stream which can be QI'ed to nsISafeOutputStream. +nsresult NS_NewSafeLocalFileOutputStream(nsIOutputStream** result, + nsIFile* file, int32_t ioFlags = -1, + int32_t perm = -1, + int32_t behaviorFlags = 0); + +nsresult NS_NewLocalFileStream(nsIFileStream** result, nsIFile* file, + int32_t ioFlags = -1, int32_t perm = -1, + int32_t behaviorFlags = 0); + +mozilla::Result<nsCOMPtr<nsIFileStream>, nsresult> NS_NewLocalFileStream( + nsIFile* file, int32_t ioFlags = -1, int32_t perm = -1, + int32_t behaviorFlags = 0); + +[[nodiscard]] nsresult NS_NewBufferedInputStream( + nsIInputStream** aResult, already_AddRefed<nsIInputStream> aInputStream, + uint32_t aBufferSize); + +mozilla::Result<nsCOMPtr<nsIInputStream>, nsresult> NS_NewBufferedInputStream( + already_AddRefed<nsIInputStream> aInputStream, uint32_t aBufferSize); + +// note: the resulting stream can be QI'ed to nsISafeOutputStream iff the +// provided stream supports it. +nsresult NS_NewBufferedOutputStream( + nsIOutputStream** aResult, already_AddRefed<nsIOutputStream> aOutputStream, + uint32_t aBufferSize); + +/** + * This function reads an inputStream and stores its content into a buffer. In + * general, you should avoid using this function because, it blocks the current + * thread until the operation is done. + * If the inputStream is async, the reading happens on an I/O thread. + * + * @param aInputStream the inputStream. + * @param aDest the destination buffer. if *aDest is null, it will be allocated + * with the size of the written data. if aDest is not null, aCount + * must greater than 0. + * @param aCount the amount of data to read. Use -1 if you want that all the + * stream is read. + * @param aWritten this pointer will be used to store the number of data + * written in the buffer. If you don't need, pass nullptr. + */ +nsresult NS_ReadInputStreamToBuffer(nsIInputStream* aInputStream, void** aDest, + int64_t aCount, + uint64_t* aWritten = nullptr); + +/** + * See the comment for NS_ReadInputStreamToBuffer + */ +nsresult NS_ReadInputStreamToString(nsIInputStream* aInputStream, + nsACString& aDest, int64_t aCount, + uint64_t* aWritten = nullptr); + +nsresult NS_LoadPersistentPropertiesFromURISpec( + nsIPersistentProperties** outResult, const nsACString& aSpec); + +/** + * NS_QueryNotificationCallbacks implements the canonical algorithm for + * querying interfaces from a channel's notification callbacks. It first + * searches the channel's notificationCallbacks attribute, and if the interface + * is not found there, then it inspects the notificationCallbacks attribute of + * the channel's loadGroup. + * + * Note: templatized only because nsIWebSocketChannel is currently not an + * nsIChannel. + */ +template <class T> +inline void NS_QueryNotificationCallbacks(T* channel, const nsIID& iid, + void** result) { + MOZ_ASSERT(channel, "null channel"); + *result = nullptr; + + nsCOMPtr<nsIInterfaceRequestor> cbs; + mozilla::Unused << channel->GetNotificationCallbacks(getter_AddRefs(cbs)); + if (cbs) cbs->GetInterface(iid, result); + if (!*result) { + // try load group's notification callbacks... + nsCOMPtr<nsILoadGroup> loadGroup; + mozilla::Unused << channel->GetLoadGroup(getter_AddRefs(loadGroup)); + if (loadGroup) { + loadGroup->GetNotificationCallbacks(getter_AddRefs(cbs)); + if (cbs) cbs->GetInterface(iid, result); + } + } +} + +// template helper: +// Note: "class C" templatized only because nsIWebSocketChannel is currently not +// an nsIChannel. + +template <class C, class T> +inline void NS_QueryNotificationCallbacks(C* channel, nsCOMPtr<T>& result) { + NS_QueryNotificationCallbacks(channel, NS_GET_TEMPLATE_IID(T), + getter_AddRefs(result)); +} + +/** + * Alternate form of NS_QueryNotificationCallbacks designed for use by + * nsIChannel implementations. + */ +inline void NS_QueryNotificationCallbacks(nsIInterfaceRequestor* callbacks, + nsILoadGroup* loadGroup, + const nsIID& iid, void** result) { + *result = nullptr; + + if (callbacks) callbacks->GetInterface(iid, result); + if (!*result) { + // try load group's notification callbacks... + if (loadGroup) { + nsCOMPtr<nsIInterfaceRequestor> cbs; + loadGroup->GetNotificationCallbacks(getter_AddRefs(cbs)); + if (cbs) cbs->GetInterface(iid, result); + } + } +} + +/** + * Returns true if channel is using Private Browsing, or false if not. + * Returns false if channel's callbacks don't implement nsILoadContext. + */ +bool NS_UsePrivateBrowsing(nsIChannel* channel); + +/** + * Returns true if the channel has visited any cross-origin URLs on any + * URLs that it was redirected through. + */ +bool NS_HasBeenCrossOrigin(nsIChannel* aChannel, bool aReport = false); + +/** + * Returns true if the channel has a safe method. + */ +bool NS_IsSafeMethodNav(nsIChannel* aChannel); + +// Unique first-party domain for separating the safebrowsing cookie. +// Note if this value is changed, code in test_cookiejars_safebrowsing.js and +// nsUrlClassifierHashCompleter.js should also be changed. +#define NECKO_SAFEBROWSING_FIRST_PARTY_DOMAIN \ + "safebrowsing.86868755-6b82-4842-b301-72671a0db32e.mozilla" + +// Unique first-party domain for separating about uri. +#define ABOUT_URI_FIRST_PARTY_DOMAIN \ + "about.ef2a7dd5-93bc-417f-a698-142c3116864f.mozilla" + +/** + * Determines whether appcache should be checked for a given principal. + */ +bool NS_ShouldCheckAppCache(nsIPrincipal* aPrincipal); + +/** + * Wraps an nsIAuthPrompt so that it can be used as an nsIAuthPrompt2. This + * method is provided mainly for use by other methods in this file. + * + * *aAuthPrompt2 should be set to null before calling this function. + */ +void NS_WrapAuthPrompt(nsIAuthPrompt* aAuthPrompt, + nsIAuthPrompt2** aAuthPrompt2); + +/** + * Gets an auth prompt from an interface requestor. This takes care of wrapping + * an nsIAuthPrompt so that it can be used as an nsIAuthPrompt2. + */ +void NS_QueryAuthPrompt2(nsIInterfaceRequestor* aCallbacks, + nsIAuthPrompt2** aAuthPrompt); + +/** + * Gets an nsIAuthPrompt2 from a channel. Use this instead of + * NS_QueryNotificationCallbacks for better backwards compatibility. + */ +void NS_QueryAuthPrompt2(nsIChannel* aChannel, nsIAuthPrompt2** aAuthPrompt); + +/* template helper */ +template <class T> +inline void NS_QueryNotificationCallbacks(nsIInterfaceRequestor* callbacks, + nsILoadGroup* loadGroup, + nsCOMPtr<T>& result) { + NS_QueryNotificationCallbacks(callbacks, loadGroup, NS_GET_TEMPLATE_IID(T), + getter_AddRefs(result)); +} + +/* template helper */ +template <class T> +inline void NS_QueryNotificationCallbacks( + const nsCOMPtr<nsIInterfaceRequestor>& aCallbacks, + const nsCOMPtr<nsILoadGroup>& aLoadGroup, nsCOMPtr<T>& aResult) { + NS_QueryNotificationCallbacks(aCallbacks.get(), aLoadGroup.get(), aResult); +} + +/* template helper */ +template <class T> +inline void NS_QueryNotificationCallbacks(const nsCOMPtr<nsIChannel>& aChannel, + nsCOMPtr<T>& aResult) { + NS_QueryNotificationCallbacks(aChannel.get(), aResult); +} + +/** + * This function returns a nsIInterfaceRequestor instance that returns the + * same result as NS_QueryNotificationCallbacks when queried. It is useful + * as the value for nsISocketTransport::securityCallbacks. + */ +nsresult NS_NewNotificationCallbacksAggregation( + nsIInterfaceRequestor* callbacks, nsILoadGroup* loadGroup, + nsIEventTarget* target, nsIInterfaceRequestor** result); + +nsresult NS_NewNotificationCallbacksAggregation( + nsIInterfaceRequestor* callbacks, nsILoadGroup* loadGroup, + nsIInterfaceRequestor** result); + +/** + * Helper function for testing online/offline state of the browser. + */ +bool NS_IsOffline(); + +/** + * Helper functions for implementing nsINestedURI::innermostURI. + * + * Note that NS_DoImplGetInnermostURI is "private" -- call + * NS_ImplGetInnermostURI instead. + */ +nsresult NS_DoImplGetInnermostURI(nsINestedURI* nestedURI, nsIURI** result); + +nsresult NS_ImplGetInnermostURI(nsINestedURI* nestedURI, nsIURI** result); + +/** + * Helper function for testing whether the given URI, or any of its + * inner URIs, has all the given protocol flags. + */ +nsresult NS_URIChainHasFlags(nsIURI* uri, uint32_t flags, bool* result); + +/** + * Helper function for getting the innermost URI for a given URI. The return + * value could be just the object passed in if it's not a nested URI. + */ +already_AddRefed<nsIURI> NS_GetInnermostURI(nsIURI* aURI); + +/** + * Helper function for getting the host name of the innermost URI for a given + * URI. The return value could be the host name of the URI passed in if it's + * not a nested URI. + */ +inline nsresult NS_GetInnermostURIHost(nsIURI* aURI, nsACString& aHost) { + aHost.Truncate(); + + // This block is optimized in order to avoid the overhead of calling + // NS_GetInnermostURI() which incurs a lot of overhead in terms of + // AddRef/Release calls. + nsCOMPtr<nsINestedURI> nestedURI = do_QueryInterface(aURI); + if (nestedURI) { + // We have a nested URI! + nsCOMPtr<nsIURI> uri; + nsresult rv = nestedURI->GetInnermostURI(getter_AddRefs(uri)); + if (NS_FAILED(rv)) { + return rv; + } + + rv = uri->GetAsciiHost(aHost); + if (NS_FAILED(rv)) { + return rv; + } + } else { + // We have a non-nested URI! + nsresult rv = aURI->GetAsciiHost(aHost); + if (NS_FAILED(rv)) { + return rv; + } + } + + return NS_OK; +} + +/** + * Get the "final" URI for a channel. This is either channel's load info + * resultPrincipalURI, if set, or GetOriginalURI. In most cases (but not all) + * load info resultPrincipalURI, if set, corresponds to URI of the channel if + * it's required to represent the actual principal for the channel. + */ +nsresult NS_GetFinalChannelURI(nsIChannel* channel, nsIURI** uri); + +// NS_SecurityHashURI must return the same hash value for any two URIs that +// compare equal according to NS_SecurityCompareURIs. Unfortunately, in the +// case of files, it's not clear we can do anything better than returning +// the schemeHash, so hashing files degenerates to storing them in a list. +uint32_t NS_SecurityHashURI(nsIURI* aURI); + +bool NS_SecurityCompareURIs(nsIURI* aSourceURI, nsIURI* aTargetURI, + bool aStrictFileOriginPolicy); + +bool NS_URIIsLocalFile(nsIURI* aURI); + +// When strict file origin policy is enabled, SecurityCompareURIs will fail for +// file URIs that do not point to the same local file. This call provides an +// alternate file-specific origin check that allows target files that are +// contained in the same directory as the source. +// +// https://developer.mozilla.org/en-US/docs/Same-origin_policy_for_file:_URIs +bool NS_RelaxStrictFileOriginPolicy(nsIURI* aTargetURI, nsIURI* aSourceURI, + bool aAllowDirectoryTarget = false); + +bool NS_IsInternalSameURIRedirect(nsIChannel* aOldChannel, + nsIChannel* aNewChannel, uint32_t aFlags); + +bool NS_IsHSTSUpgradeRedirect(nsIChannel* aOldChannel, nsIChannel* aNewChannel, + uint32_t aFlags); + +nsresult NS_LinkRedirectChannels(uint64_t channelId, + nsIParentChannel* parentChannel, + nsIChannel** _result); + +/** + * Helper function which checks whether the channel can be + * openend using Open() or has to fall back to opening + * the channel using Open(). + */ +nsresult NS_MaybeOpenChannelUsingOpen(nsIChannel* aChannel, + nsIInputStream** aStream); + +/** + * Helper function which checks whether the channel can be + * openend using AsyncOpen() or has to fall back to opening + * the channel using AsyncOpen(). + */ +nsresult NS_MaybeOpenChannelUsingAsyncOpen(nsIChannel* aChannel, + nsIStreamListener* aListener); + +/** + * Returns nsILoadInfo::EMBEDDER_POLICY_REQUIRE_CORP if `aHeader` is + * "require-corp" and nsILoadInfo::EMBEDDER_POLICY_NULL otherwise. + * + * See: https://mikewest.github.io/corpp/#parsing + */ +nsILoadInfo::CrossOriginEmbedderPolicy +NS_GetCrossOriginEmbedderPolicyFromHeader(const nsACString& aHeader); + +/** Given the first (disposition) token from a Content-Disposition header, + * tell whether it indicates the content is inline or attachment + * @param aDispToken the disposition token from the content-disposition header + */ +uint32_t NS_GetContentDispositionFromToken(const nsAString& aDispToken); + +/** Determine the disposition (inline/attachment) of the content based on the + * Content-Disposition header + * @param aHeader the content-disposition header (full value) + * @param aChan the channel the header came from + */ +uint32_t NS_GetContentDispositionFromHeader(const nsACString& aHeader, + nsIChannel* aChan = nullptr); + +/** Extracts the filename out of a content-disposition header + * @param aFilename [out] The filename. Can be empty on error. + * @param aDisposition Value of a Content-Disposition header + + */ +nsresult NS_GetFilenameFromDisposition(nsAString& aFilename, + const nsACString& aDisposition); + +/** + * Make sure Personal Security Manager is initialized + */ +void net_EnsurePSMInit(); + +/** + * Test whether a URI is "about:blank". |uri| must not be null + */ +bool NS_IsAboutBlank(nsIURI* uri); + +nsresult NS_GenerateHostPort(const nsCString& host, int32_t port, + nsACString& hostLine); + +/** + * Sniff the content type for a given request or a given buffer. + * + * aSnifferType can be either NS_CONTENT_SNIFFER_CATEGORY or + * NS_DATA_SNIFFER_CATEGORY. The function returns the sniffed content type + * in the aSniffedType argument. This argument will not be modified if the + * content type could not be sniffed. + */ +void NS_SniffContent(const char* aSnifferType, nsIRequest* aRequest, + const uint8_t* aData, uint32_t aLength, + nsACString& aSniffedType); + +/** + * Whether the channel was created to load a srcdoc document. + * Note that view-source:about:srcdoc is classified as a srcdoc document by + * this function, which may not be applicable everywhere. + */ +bool NS_IsSrcdocChannel(nsIChannel* aChannel); + +/** + * Return true if the given string is a reasonable HTTP header value given the + * definition in RFC 2616 section 4.2. Currently we don't pay the cost to do + * full, sctrict validation here since it would require fulling parsing the + * value. + */ +bool NS_IsReasonableHTTPHeaderValue(const nsACString& aValue); + +/** + * Return true if the given string is a valid HTTP token per RFC 2616 section + * 2.2. + */ +bool NS_IsValidHTTPToken(const nsACString& aToken); + +/** + * Strip the leading or trailing HTTP whitespace per fetch spec section 2.2. + */ +void NS_TrimHTTPWhitespace(const nsACString& aSource, nsACString& aDest); + +/** + * Return true if the given request must be upgraded to HTTPS. + * If |aResultCallback| is provided and the storage is not ready to read, the + * result will be sent back through the callback and |aWillCallback| will be + * true. Otherwiew, the result will be set to |aShouldUpgrade| and + * |aWillCallback| is false. + */ +nsresult NS_ShouldSecureUpgrade( + nsIURI* aURI, nsILoadInfo* aLoadInfo, nsIPrincipal* aChannelResultPrincipal, + bool aPrivateBrowsing, bool aAllowSTS, + const mozilla::OriginAttributes& aOriginAttributes, bool& aShouldUpgrade, + std::function<void(bool, nsresult)>&& aResultCallback, bool& aWillCallback); + +/** + * Returns an https URI for channels that need to go through secure upgrades. + */ +nsresult NS_GetSecureUpgradedURI(nsIURI* aURI, nsIURI** aUpgradedURI); + +nsresult NS_CompareLoadInfoAndLoadContext(nsIChannel* aChannel); + +/** + * Return true if this channel should be classified by the URL classifier. + */ +bool NS_ShouldClassifyChannel(nsIChannel* aChannel); + +/** + * Helper to set the blocking reason on loadinfo of the channel. + */ +nsresult NS_SetRequestBlockingReason(nsIChannel* channel, uint32_t reason); +nsresult NS_SetRequestBlockingReason(nsILoadInfo* loadInfo, uint32_t reason); +nsresult NS_SetRequestBlockingReasonIfNull(nsILoadInfo* loadInfo, + uint32_t reason); + +namespace mozilla { +namespace net { + +const static uint64_t kJS_MAX_SAFE_UINTEGER = +9007199254740991ULL; +const static int64_t kJS_MIN_SAFE_INTEGER = -9007199254740991LL; +const static int64_t kJS_MAX_SAFE_INTEGER = +9007199254740991LL; + +// Make sure a 64bit value can be captured by JS MAX_SAFE_INTEGER +bool InScriptableRange(int64_t val); + +// Make sure a 64bit value can be captured by JS MAX_SAFE_INTEGER +bool InScriptableRange(uint64_t val); + +/** + * Given the value of a single header field (such as + * Content-Disposition and Content-Type) and the name of a parameter + * (e.g. filename, name, charset), returns the value of the parameter. + * See nsIMIMEHeaderParam.idl for more information. + * + * @param aHeaderVal a header string to get the value of a parameter + * from. + * @param aParamName the name of a MIME header parameter (e.g. + * filename, name, charset). If empty or nullptr, + * returns the first (possibly) _unnamed_ 'parameter'. + * @return the value of <code>aParamName</code> in Unichar(UTF-16). + */ +nsresult GetParameterHTTP(const nsACString& aHeaderVal, const char* aParamName, + nsAString& aResult); + +/** + * Helper function that determines if channel is an HTTP POST. + * + * @param aChannel + * The channel to test + * + * @return True if channel is an HTTP post. + */ +bool ChannelIsPost(nsIChannel* aChannel); + +/** + * Convenience functions for verifying nsIURI schemes. These functions simply + * wrap aURI->SchemeIs(), but specify the protocol as part of the function name. + */ + +bool SchemeIsHTTP(nsIURI* aURI); +bool SchemeIsHTTPS(nsIURI* aURI); +bool SchemeIsJavascript(nsIURI* aURI); +bool SchemeIsChrome(nsIURI* aURI); +bool SchemeIsAbout(nsIURI* aURI); +bool SchemeIsBlob(nsIURI* aURI); +bool SchemeIsFile(nsIURI* aURI); +bool SchemeIsData(nsIURI* aURI); +bool SchemeIsViewSource(nsIURI* aURI); +bool SchemeIsResource(nsIURI* aURI); +bool SchemeIsFTP(nsIURI* aURI); +} // namespace net +} // namespace mozilla + +#endif // !nsNetUtil_h__ diff --git a/netwerk/base/nsNetworkInfoService.cpp b/netwerk/base/nsNetworkInfoService.cpp new file mode 100644 index 0000000000..4d3da66a8e --- /dev/null +++ b/netwerk/base/nsNetworkInfoService.cpp @@ -0,0 +1,94 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +#if defined(XP_MACOSX) || defined(XP_LINUX) +# include <unistd.h> +#elif defined(XP_WIN) +# include <winsock2.h> +#endif + +#include "nsNetworkInfoService.h" + +#if defined(XP_MACOSX) || defined(XP_WIN) || defined(XP_LINUX) +# include "NetworkInfoServiceImpl.h" +#else +# error "Unsupported platform for nsNetworkInfoService! Check moz.build" +#endif + +namespace mozilla::net { + +NS_IMPL_ISUPPORTS(nsNetworkInfoService, nsINetworkInfoService) + +nsNetworkInfoService::nsNetworkInfoService() = default; + +nsresult nsNetworkInfoService::Init() { return NS_OK; } + +nsresult nsNetworkInfoService::ListNetworkAddresses( + nsIListNetworkAddressesListener* aListener) { + nsresult rv; + + AddrMapType addrMap; + rv = DoListAddresses(addrMap); + if (NS_WARN_IF(NS_FAILED(rv))) { + aListener->OnListNetworkAddressesFailed(); + return NS_OK; + } + + uint32_t addrCount = addrMap.Count(); + nsTArray<nsCString> addrStrings; + if (!addrStrings.SetCapacity(addrCount, fallible)) { + aListener->OnListNetworkAddressesFailed(); + return NS_OK; + } + + for (auto iter = addrMap.Iter(); !iter.Done(); iter.Next()) { + addrStrings.AppendElement(iter.Data()); + } + aListener->OnListedNetworkAddresses(addrStrings); + return NS_OK; +} + +// TODO: Bug 1275373: https://bugzilla.mozilla.org/show_bug.cgi?id=1275373 +// Use platform-specific implementation of DoGetHostname on Cocoa and Windows. +static nsresult DoGetHostname(nsACString& aHostname) { + char hostnameBuf[256]; + int result = gethostname(hostnameBuf, 256); + if (result == -1) { + return NS_ERROR_FAILURE; + } + + // Ensure that there is always a terminating NUL byte. + hostnameBuf[255] = '\0'; + + // Find the first '.', terminate string there. + char* dotLocation = strchr(hostnameBuf, '.'); + if (dotLocation) { + *dotLocation = '\0'; + } + + if (strlen(hostnameBuf) == 0) { + return NS_ERROR_FAILURE; + } + + aHostname.AssignASCII(hostnameBuf); + return NS_OK; +} + +nsresult nsNetworkInfoService::GetHostname(nsIGetHostnameListener* aListener) { + nsresult rv; + nsCString hostnameStr; + rv = DoGetHostname(hostnameStr); + if (NS_FAILED(rv)) { + aListener->OnGetHostnameFailed(); + return NS_OK; + } + + aListener->OnGotHostname(hostnameStr); + + return NS_OK; +} + +} // namespace mozilla::net diff --git a/netwerk/base/nsNetworkInfoService.h b/netwerk/base/nsNetworkInfoService.h new file mode 100644 index 0000000000..d7b449b96f --- /dev/null +++ b/netwerk/base/nsNetworkInfoService.h @@ -0,0 +1,40 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +#ifndef mozilla_net_nsNetworkInfoService_h +#define mozilla_net_nsNetworkInfoService_h + +#include "nsISupportsImpl.h" + +#include "nsINetworkInfoService.h" + +#define NETWORKINFOSERVICE_CID \ + { \ + 0x296d0900, 0xf8ef, 0x4df0, { \ + 0x9c, 0x35, 0xdb, 0x58, 0x62, 0xab, 0xc5, 0x8d \ + } \ + } + +namespace mozilla { +namespace net { + +class nsNetworkInfoService final : public nsINetworkInfoService { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSINETWORKINFOSERVICE + + nsresult Init(); + + explicit nsNetworkInfoService(); + + private: + virtual ~nsNetworkInfoService() = default; +}; + +} // namespace net +} // namespace mozilla + +#endif // mozilla_dom_nsNetworkInfoService_h diff --git a/netwerk/base/nsPACMan.cpp b/netwerk/base/nsPACMan.cpp new file mode 100644 index 0000000000..509c9a3508 --- /dev/null +++ b/netwerk/base/nsPACMan.cpp @@ -0,0 +1,964 @@ +/* -*- 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 "nsNetUtil.h" +#include "nsThreadUtils.h" +#include "mozilla/Result.h" +#include "mozilla/ResultExtensions.h" +#include "mozilla/Telemetry.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<nsIEventTarget> target = mPACMan->GetNeckoTarget(); + mPACMan->mPAC.Init(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"); + if (!sThreadLocalSetup) { + sThreadLocalSetup = true; + PR_NewThreadPrivateIndex(&sThreadLocalIndex, nullptr); + } + mPAC.SetThreadLocalIndex(sThreadLocalIndex); + mIncludePath = Preferences::GetBool(kPACIncludePath, false); +} + +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))); + } + + return mPACThread->Dispatch( + e.forget(), + aSync ? nsIEventTarget::DISPATCH_SYNC : nsIEventTarget::DISPATCH_NORMAL); +} + +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()) + : GetCurrentEventTarget()->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); + + 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, + 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())); + + if (mShutdown || IsLoading()) { + 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) { + 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"); + + { + 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; + } + } + + 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 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 diff --git a/netwerk/base/nsPACMan.h b/netwerk/base/nsPACMan.h new file mode 100644 index 0000000000..373220ab30 --- /dev/null +++ b/netwerk/base/nsPACMan.h @@ -0,0 +1,295 @@ +/* -*- 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/. */ + +#ifndef nsPACMan_h__ +#define nsPACMan_h__ + +#include "mozilla/Atomics.h" +#include "mozilla/Attributes.h" +#include "mozilla/DataMutex.h" +#include "mozilla/LinkedList.h" +#include "mozilla/Logging.h" +#include "mozilla/net/NeckoTargetHolder.h" +#include "mozilla/TimeStamp.h" +#include "nsCOMPtr.h" +#include "nsIChannelEventSink.h" +#include "nsIInterfaceRequestor.h" +#include "nsIStreamLoader.h" +#include "nsThreadUtils.h" +#include "nsIURI.h" +#include "nsString.h" +#include "ProxyAutoConfig.h" + +class nsISystemProxySettings; +class nsIDHCPClient; +class nsIThread; + +namespace mozilla { +namespace net { + +class nsPACMan; +class WaitForThreadShutdown; + +/** + * This class defines a callback interface used by AsyncGetProxyForURI. + */ +class NS_NO_VTABLE nsPACManCallback : public nsISupports { + public: + /** + * This method is invoked on the same thread that called AsyncGetProxyForURI. + * + * @param status + * This parameter indicates whether or not the PAC query succeeded. + * @param pacString + * This parameter holds the value of the PAC string. It is empty when + * status is a failure code. + * @param newPACURL + * This parameter holds the URL of a new PAC file that should be loaded + * before the query is evaluated again. At least one of pacString and + * newPACURL should be 0 length. + */ + virtual void OnQueryComplete(nsresult status, const nsACString& pacString, + const nsACString& newPACURL) = 0; +}; + +class PendingPACQuery final : public Runnable, + public LinkedListElement<PendingPACQuery> { + public: + PendingPACQuery(nsPACMan* pacMan, nsIURI* uri, nsPACManCallback* callback, + uint32_t flags, bool mainThreadResponse); + + // can be called from either thread + void Complete(nsresult status, const nsACString& pacString); + void UseAlternatePACFile(const nsACString& pacURL); + + nsCString mSpec; + nsCString mScheme; + nsCString mHost; + int32_t mPort; + uint32_t mFlags; + + NS_IMETHOD Run(void) override; /* Runnable */ + + private: + nsPACMan* mPACMan; // weak reference + + private: + RefPtr<nsPACManCallback> mCallback; + bool mOnMainThreadOnly; +}; + +/** + * This class provides an abstraction layer above the PAC thread. The methods + * defined on this class are intended to be called on the main thread only. + */ + +class nsPACMan final : public nsIStreamLoaderObserver, + public nsIInterfaceRequestor, + public nsIChannelEventSink, + public NeckoTargetHolder { + public: + NS_DECL_THREADSAFE_ISUPPORTS + + explicit nsPACMan(nsISerialEventTarget* mainThreadEventTarget); + + /** + * This method may be called to shutdown the PAC manager. Any async queries + * that have not yet completed will either finish normally or be canceled by + * the time this method returns. + */ + void Shutdown(); + + /** + * This method queries a PAC result asynchronously. The callback runs on the + * calling thread. If the PAC file has not yet been loaded, then this method + * will queue up the request, and complete it once the PAC file has been + * loaded. + * + * @param uri + * The URI to query. + * @param callback + * The callback to run once the PAC result is available. + * @param flags + * A bit-wise combination of the RESOLVE_ flags defined above. Pass + * 0 to specify the default behavior. + * @param mustCallbackOnMainThread + * If set to false the callback can be made from the PAC thread + */ + nsresult AsyncGetProxyForURI(nsIURI* uri, nsPACManCallback* callback, + uint32_t flags, bool mustCallbackOnMainThread); + + /** + * This method may be called to reload the PAC file. While we are loading + * the PAC file, any asynchronous PAC queries will be queued up to be + * processed once the PAC file finishes loading. + * + * @param aSpec + * The non normalized uri spec of this URI used for comparison with + * system proxy settings to determine if the PAC uri has changed. + */ + nsresult LoadPACFromURI(const nsACString& aSpec); + + /** + * Returns true if we are currently loading the PAC file. + */ + bool IsLoading() { + auto loader = mLoader.Lock(); + return loader.ref() != nullptr; + } + + /** + * Returns true if the given URI matches the URI of our PAC file or the + * URI it has been redirected to. In the case of a chain of redirections + * only the current one being followed and the original are considered + * becuase this information is used, respectively, to determine if we + * should bypass the proxy (to fetch the pac file) or if the pac + * configuration has changed (and we should reload the pac file) + */ + bool IsPACURI(const nsACString& spec) { + return mPACURISpec.Equals(spec) || mPACURIRedirectSpec.Equals(spec) || + mNormalPACURISpec.Equals(spec); + } + + bool IsPACURI(nsIURI* uri) { + if (mPACURISpec.IsEmpty() && mPACURIRedirectSpec.IsEmpty()) { + return false; + } + + nsAutoCString tmp; + nsresult rv = uri->GetSpec(tmp); + if (NS_FAILED(rv)) { + return false; + } + + return IsPACURI(tmp); + } + + bool IsUsingWPAD() { return mAutoDetect; } + + nsresult Init(nsISystemProxySettings*); + static nsPACMan* sInstance; + + // PAC thread operations only + void ProcessPendingQ(); + void CancelPendingQ(nsresult, bool aShutdown); + + void SetWPADOverDHCPEnabled(bool aValue) { mWPADOverDHCPEnabled = aValue; } + + private: + NS_DECL_NSISTREAMLOADEROBSERVER + NS_DECL_NSIINTERFACEREQUESTOR + NS_DECL_NSICHANNELEVENTSINK + + friend class PendingPACQuery; + friend class PACLoadComplete; + friend class ConfigureWPADComplete; + friend class ExecutePACThreadAction; + friend class WaitForThreadShutdown; + friend class TestPACMan; + + ~nsPACMan(); + + /** + * Cancel any existing load if any. + */ + void CancelExistingLoad(); + + /** + * Start loading the PAC file. + */ + void StartLoading(); + + /** + * Continue loading the PAC file. + */ + void ContinueLoadingAfterPACUriKnown(); + + /** + * This method may be called to reload the PAC file. While we are loading + * the PAC file, any asynchronous PAC queries will be queued up to be + * processed once the PAC file finishes loading. + * + * @param aSpec + * The non normalized uri spec of this URI used for comparison with + * system proxy settings to determine if the PAC uri has changed. + * @param aResetLoadFailureCount + * A flag saying whether the exponential back-off for attempting to + * reload the PAC should be reset. + */ + nsresult LoadPACFromURI(const nsACString& aSpec, bool aResetLoadFailureCount); + + /** + * Reload the PAC file if there is reason to. + */ + void MaybeReloadPAC(); + + /** + * Called when we fail to load the PAC file. + */ + void OnLoadFailure(); + + /** + * PostQuery() only runs on the PAC thread and it is used to + * place a pendingPACQuery into the queue and potentially + * execute the queue if it was otherwise empty + */ + nsresult PostQuery(PendingPACQuery* query); + + // Having found the PAC URI on the PAC thread, copy it to a string which + // can be altered on the main thread. + void AssignPACURISpec(const nsACString& aSpec); + + // PAC thread operations only + void PostProcessPendingQ(); + void PostCancelPendingQ(nsresult, bool aShutdown = false); + bool ProcessPending(); + nsresult GetPACFromDHCP(nsACString& aSpec); + nsresult ConfigureWPAD(nsACString& aSpec); + + private: + /** + * Dispatches a runnable to the PAC processing thread. Handles lazy + * instantiation of the thread. + * + * @param aEvent The event to disptach. + * @param aSync Whether or not this should be synchronous dispatch. + */ + nsresult DispatchToPAC(already_AddRefed<nsIRunnable> aEvent, + bool aSync = false); + + ProxyAutoConfig mPAC; + nsCOMPtr<nsIThread> mPACThread; + nsCOMPtr<nsISystemProxySettings> mSystemProxySettings; + nsCOMPtr<nsIDHCPClient> mDHCPClient; + + LinkedList<PendingPACQuery> mPendingQ; /* pac thread only */ + + // These specs are not nsIURI so that they can be used off the main thread. + // The non-normalized versions are directly from the configuration, the + // normalized version has been extracted from an nsIURI + nsCString mPACURISpec; + nsCString mPACURIRedirectSpec; + nsCString mNormalPACURISpec; + + DataMutex<nsCOMPtr<nsIStreamLoader>> mLoader; + bool mLoadPending; + Atomic<bool, Relaxed> mShutdown; + TimeStamp mScheduledReload; + uint32_t mLoadFailureCount; + + bool mInProgress; + bool mIncludePath; + bool mAutoDetect; + bool mWPADOverDHCPEnabled; + int32_t mProxyConfigType; +}; + +extern LazyLogModule gProxyLog; + +} // namespace net +} // namespace mozilla + +#endif // nsPACMan_h__ diff --git a/netwerk/base/nsPISocketTransportService.idl b/netwerk/base/nsPISocketTransportService.idl new file mode 100644 index 0000000000..e7c8ac5a60 --- /dev/null +++ b/netwerk/base/nsPISocketTransportService.idl @@ -0,0 +1,59 @@ +/* -*- 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 "nsISocketTransportService.idl" + +/** + * This is a private interface used by the internals of the networking library. + * It will never be frozen. Do not use it in external code. + */ +[builtinclass, scriptable, uuid(18f73bf1-b35b-4b7b-aa9a-11bcbdbc389c)] +interface nsPISocketTransportService : nsIRoutedSocketTransportService +{ + /** + * init/shutdown routines. + */ + void init(); + void shutdown(in bool aXpcomShutdown); + + /** + * controls the TCP sender window clamp + */ + readonly attribute long sendBufferSize; + + /** + * Controls whether the socket transport service is offline. + * Setting it offline will cause non-local socket detachment. + */ + attribute boolean offline; + + /** + * Controls the default timeout (in seconds) for sending keepalive probes. + */ + readonly attribute long keepaliveIdleTime; + + /** + * Controls the default interval (in seconds) between retrying keepalive probes. + */ + readonly attribute long keepaliveRetryInterval; + + /** + * Controls the default retransmission count for keepalive probes. + */ + readonly attribute long keepaliveProbeCount; +}; + +%{C++ +/* + * I/O activity observer topic. Sends out information about the + * amount of data we're sending/receiving via sockets and disk files. + * + * Activated via the "io.activity.enabled" preference. + */ +#define NS_IO_ACTIVITY "io-activity" + + +%} diff --git a/netwerk/base/nsPreloadedStream.cpp b/netwerk/base/nsPreloadedStream.cpp new file mode 100644 index 0000000000..4effa08066 --- /dev/null +++ b/netwerk/base/nsPreloadedStream.cpp @@ -0,0 +1,122 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "nsPreloadedStream.h" +#include "nsIRunnable.h" + +#include "nsThreadUtils.h" +#include <algorithm> + +namespace mozilla { +namespace net { + +NS_IMPL_ISUPPORTS(nsPreloadedStream, nsIInputStream, nsIAsyncInputStream) + +nsPreloadedStream::nsPreloadedStream(nsIAsyncInputStream* aStream, + const char* data, uint32_t datalen) + : mStream(aStream), mOffset(0), mLen(datalen) { + mBuf = (char*)moz_xmalloc(datalen); + memcpy(mBuf, data, datalen); +} + +nsPreloadedStream::~nsPreloadedStream() { free(mBuf); } + +NS_IMETHODIMP +nsPreloadedStream::Close() { + mLen = 0; + return mStream->Close(); +} + +NS_IMETHODIMP +nsPreloadedStream::Available(uint64_t* _retval) { + uint64_t avail = 0; + + nsresult rv = mStream->Available(&avail); + if (NS_FAILED(rv)) return rv; + *_retval = avail + mLen; + return NS_OK; +} + +NS_IMETHODIMP +nsPreloadedStream::Read(char* aBuf, uint32_t aCount, uint32_t* _retval) { + if (!mLen) return mStream->Read(aBuf, aCount, _retval); + + uint32_t toRead = std::min(mLen, aCount); + memcpy(aBuf, mBuf + mOffset, toRead); + mOffset += toRead; + mLen -= toRead; + *_retval = toRead; + return NS_OK; +} + +NS_IMETHODIMP +nsPreloadedStream::ReadSegments(nsWriteSegmentFun aWriter, void* aClosure, + uint32_t aCount, uint32_t* result) { + if (!mLen) return mStream->ReadSegments(aWriter, aClosure, aCount, result); + + *result = 0; + while (mLen > 0 && aCount > 0) { + uint32_t toRead = std::min(mLen, aCount); + uint32_t didRead = 0; + nsresult rv; + + rv = aWriter(this, aClosure, mBuf + mOffset, *result, toRead, &didRead); + + if (NS_FAILED(rv)) return NS_OK; + + *result += didRead; + mOffset += didRead; + mLen -= didRead; + aCount -= didRead; + } + + return NS_OK; +} + +NS_IMETHODIMP +nsPreloadedStream::IsNonBlocking(bool* _retval) { + return mStream->IsNonBlocking(_retval); +} + +NS_IMETHODIMP +nsPreloadedStream::CloseWithStatus(nsresult aStatus) { + mLen = 0; + return mStream->CloseWithStatus(aStatus); +} + +class RunOnThread : public Runnable { + public: + RunOnThread(nsIAsyncInputStream* aStream, nsIInputStreamCallback* aCallback) + : Runnable("net::RunOnThread"), mStream(aStream), mCallback(aCallback) {} + + virtual ~RunOnThread() = default; + + NS_IMETHOD Run() override { + mCallback->OnInputStreamReady(mStream); + return NS_OK; + } + + private: + nsCOMPtr<nsIAsyncInputStream> mStream; + nsCOMPtr<nsIInputStreamCallback> mCallback; +}; + +NS_IMETHODIMP +nsPreloadedStream::AsyncWait(nsIInputStreamCallback* aCallback, uint32_t aFlags, + uint32_t aRequestedCount, + nsIEventTarget* aEventTarget) { + if (!mLen) + return mStream->AsyncWait(aCallback, aFlags, aRequestedCount, aEventTarget); + + if (!aCallback) return NS_OK; + + if (!aEventTarget) return aCallback->OnInputStreamReady(this); + + nsCOMPtr<nsIRunnable> event = new RunOnThread(this, aCallback); + return aEventTarget->Dispatch(event, nsIEventTarget::DISPATCH_NORMAL); +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/nsPreloadedStream.h b/netwerk/base/nsPreloadedStream.h new file mode 100644 index 0000000000..368cfbbe1e --- /dev/null +++ b/netwerk/base/nsPreloadedStream.h @@ -0,0 +1,52 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +/** + * This class allows you to prefix an existing nsIAsyncInputStream + * with a preloaded block of data known at construction time by wrapping the + * two data sources into a new nsIAsyncInputStream. Readers of the new + * stream initially see the preloaded data and when that has been exhausted + * they automatically read from the wrapped stream. + * + * It is used by nsHttpConnection when it has over buffered while reading from + * the HTTP input socket and accidentally consumed data that belongs to + * a different protocol via the HTTP Upgrade mechanism. That over-buffered + * data is preloaded together with the input socket to form the new input socket + * given to the new protocol handler. + */ + +#ifndef nsPreloadedStream_h__ +#define nsPreloadedStream_h__ + +#include "nsIAsyncInputStream.h" +#include "nsCOMPtr.h" +#include "mozilla/Attributes.h" + +namespace mozilla { +namespace net { + +class nsPreloadedStream final : public nsIAsyncInputStream { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIINPUTSTREAM + NS_DECL_NSIASYNCINPUTSTREAM + + nsPreloadedStream(nsIAsyncInputStream* aStream, const char* data, + uint32_t datalen); + + private: + ~nsPreloadedStream(); + + nsCOMPtr<nsIAsyncInputStream> mStream; + + char* mBuf; + uint32_t mOffset; + uint32_t mLen; +}; + +} // namespace net +} // namespace mozilla + +#endif diff --git a/netwerk/base/nsProtocolProxyService.cpp b/netwerk/base/nsProtocolProxyService.cpp new file mode 100644 index 0000000000..fdfe24cc4a --- /dev/null +++ b/netwerk/base/nsProtocolProxyService.cpp @@ -0,0 +1,2376 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=4 sw=2 sts=2 et: */ +/* 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 "mozilla/ArrayUtils.h" +#include "mozilla/Attributes.h" +#include "mozilla/AutoRestore.h" + +#include "nsProtocolProxyService.h" +#include "nsProxyInfo.h" +#include "nsIClassInfoImpl.h" +#include "nsIIOService.h" +#include "nsIObserverService.h" +#include "nsIProtocolHandler.h" +#include "nsIProtocolProxyCallback.h" +#include "nsIChannel.h" +#include "nsICancelable.h" +#include "nsIDNSService.h" +#include "nsPIDNSService.h" +#include "nsIPrefBranch.h" +#include "nsIPrefService.h" +#include "nsContentUtils.h" +#include "nsThreadUtils.h" +#include "nsQueryObject.h" +#include "nsSOCKSIOLayer.h" +#include "nsString.h" +#include "nsNetUtil.h" +#include "nsNetCID.h" +#include "plstr.h" +#include "prnetdb.h" +#include "nsPACMan.h" +#include "nsProxyRelease.h" +#include "mozilla/Mutex.h" +#include "mozilla/CondVar.h" +#include "nsISystemProxySettings.h" +#include "nsINetworkLinkService.h" +#include "nsIHttpChannelInternal.h" +#include "mozilla/dom/nsMixedContentBlocker.h" +#include "mozilla/Logging.h" +#include "mozilla/StaticPrefs_network.h" +#include "mozilla/Tokenizer.h" +#include "mozilla/Unused.h" + +//---------------------------------------------------------------------------- + +namespace mozilla { +namespace net { + +extern const char kProxyType_HTTP[]; +extern const char kProxyType_HTTPS[]; +extern const char kProxyType_SOCKS[]; +extern const char kProxyType_SOCKS4[]; +extern const char kProxyType_SOCKS5[]; +extern const char kProxyType_DIRECT[]; + +#undef LOG +#define LOG(args) MOZ_LOG(gProxyLog, LogLevel::Debug, args) + +//---------------------------------------------------------------------------- + +#define PROXY_PREF_BRANCH "network.proxy" +#define PROXY_PREF(x) PROXY_PREF_BRANCH "." x + +//---------------------------------------------------------------------------- + +// This structure is intended to be allocated on the stack +struct nsProtocolInfo { + nsAutoCString scheme; + uint32_t flags; + int32_t defaultPort; +}; + +//---------------------------------------------------------------------------- + +// Return the channel's proxy URI, or if it doesn't exist, the +// channel's main URI. +static nsresult GetProxyURI(nsIChannel* channel, nsIURI** aOut) { + nsresult rv = NS_OK; + nsCOMPtr<nsIURI> proxyURI; + nsCOMPtr<nsIHttpChannelInternal> httpChannel(do_QueryInterface(channel)); + if (httpChannel) { + rv = httpChannel->GetProxyURI(getter_AddRefs(proxyURI)); + } + if (!proxyURI) { + rv = channel->GetURI(getter_AddRefs(proxyURI)); + } + if (NS_FAILED(rv)) { + return rv; + } + proxyURI.forget(aOut); + return NS_OK; +} + +//----------------------------------------------------------------------------- + +nsProtocolProxyService::FilterLink::FilterLink(uint32_t p, + nsIProtocolProxyFilter* f) + : position(p), filter(f), channelFilter(nullptr) { + LOG(("nsProtocolProxyService::FilterLink::FilterLink %p, filter=%p", this, + f)); +} +nsProtocolProxyService::FilterLink::FilterLink( + uint32_t p, nsIProtocolProxyChannelFilter* cf) + : position(p), filter(nullptr), channelFilter(cf) { + LOG(("nsProtocolProxyService::FilterLink::FilterLink %p, channel-filter=%p", + this, cf)); +} + +nsProtocolProxyService::FilterLink::~FilterLink() { + LOG(("nsProtocolProxyService::FilterLink::~FilterLink %p", this)); +} + +//----------------------------------------------------------------------------- + +// The nsPACManCallback portion of this implementation should be run +// on the main thread - so call nsPACMan::AsyncGetProxyForURI() with +// a true mainThreadResponse parameter. +class nsAsyncResolveRequest final : public nsIRunnable, + public nsPACManCallback, + public nsICancelable { + public: + NS_DECL_THREADSAFE_ISUPPORTS + + nsAsyncResolveRequest(nsProtocolProxyService* pps, nsIChannel* channel, + uint32_t aResolveFlags, + nsIProtocolProxyCallback* callback) + : mStatus(NS_OK), + mDispatched(false), + mResolveFlags(aResolveFlags), + mPPS(pps), + mXPComPPS(pps), + mChannel(channel), + mCallback(callback) { + NS_ASSERTION(mCallback, "null callback"); + } + + private: + ~nsAsyncResolveRequest() { + if (!NS_IsMainThread()) { + // these xpcom pointers might need to be proxied back to the + // main thread to delete safely, but if this request had its + // callbacks called normally they will all be null and this is a nop + + if (mChannel) { + NS_ReleaseOnMainThread("nsAsyncResolveRequest::mChannel", + mChannel.forget()); + } + + if (mCallback) { + NS_ReleaseOnMainThread("nsAsyncResolveRequest::mCallback", + mCallback.forget()); + } + + if (mProxyInfo) { + NS_ReleaseOnMainThread("nsAsyncResolveRequest::mProxyInfo", + mProxyInfo.forget()); + } + + if (mXPComPPS) { + NS_ReleaseOnMainThread("nsAsyncResolveRequest::mXPComPPS", + mXPComPPS.forget()); + } + } + } + + // Helper class to loop over all registered asynchronous filters. + // There is a cycle between nsAsyncResolveRequest and this class that + // is broken after the last filter has called back on this object. + class AsyncApplyFilters final : public nsIProxyProtocolFilterResult, + public nsIRunnable, + public nsICancelable { + // The reference counter is thread-safe, but the processing logic is + // considered single thread only. We want the counter be thread safe, + // since this class can be released on a background thread. + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIPROXYPROTOCOLFILTERRESULT + NS_DECL_NSIRUNNABLE + NS_DECL_NSICANCELABLE + + typedef std::function<nsresult(nsAsyncResolveRequest*, nsIProxyInfo*, bool)> + Callback; + + explicit AsyncApplyFilters(nsProtocolInfo& aInfo, + Callback const& aCallback); + // This method starts the processing or filters. If all of them + // answer synchronously (call back from within applyFilters) this method + // will return immediately and the returning result will carry return + // result of the callback given in constructor. + // This method is looping the registered filters (that have been copied + // locally) as long as an answer from a filter is obtained synchronously. + // Note that filters are processed serially to let them build a list + // of proxy info. + nsresult AsyncProcess(nsAsyncResolveRequest* aRequest); + + private: + typedef nsProtocolProxyService::FilterLink FilterLink; + + virtual ~AsyncApplyFilters(); + // Processes the next filter and loops until a filter is successfully + // called on or it has called back to us. + nsresult ProcessNextFilter(); + // Called after the last filter has been processed (=called back or failed + // to be called on) + nsresult Finish(); + + nsProtocolInfo mInfo; + // This is nullified before we call back on the request or when + // Cancel() on this object has been called to break the cycle + // and signal to stop. + RefPtr<nsAsyncResolveRequest> mRequest; + Callback mCallback; + // A shallow snapshot of filters as they were registered at the moment + // we started to process filters for the given resolve request. + nsTArray<RefPtr<FilterLink>> mFiltersCopy; + + nsTArray<RefPtr<FilterLink>>::index_type mNextFilterIndex; + // true when we are calling ProcessNextFilter() from inside AsyncProcess(), + // false otherwise. + bool mProcessingInLoop; + // true after a filter called back to us with a result, dropped to false + // just before we call a filter. + bool mFilterCalledBack; + + // This keeps the initial value we pass to the first filter in line and also + // collects the result from each filter call. + nsCOMPtr<nsIProxyInfo> mProxyInfo; + + // The logic is written as non-thread safe, assert single-thread usage. + nsCOMPtr<nsISerialEventTarget> mProcessingThread; + }; + + void EnsureResolveFlagsMatch() { + nsCOMPtr<nsIProxyInfo> proxyInfo = mProxyInfo; + while (proxyInfo) { + proxyInfo->SetResolveFlags(mResolveFlags); + proxyInfo->GetFailoverProxy(getter_AddRefs(proxyInfo)); + } + } + + public: + nsresult ProcessLocally(nsProtocolInfo& info, nsIProxyInfo* pi, + bool isSyncOK) { + SetResult(NS_OK, pi); + + auto consumeFiltersResult = [isSyncOK](nsAsyncResolveRequest* ctx, + nsIProxyInfo* pi, + bool aCalledAsync) -> nsresult { + ctx->SetResult(NS_OK, pi); + if (isSyncOK || aCalledAsync) { + ctx->Run(); + return NS_OK; + } + + return ctx->DispatchCallback(); + }; + + mAsyncFilterApplier = new AsyncApplyFilters(info, consumeFiltersResult); + // may call consumeFiltersResult() directly + return mAsyncFilterApplier->AsyncProcess(this); + } + + void SetResult(nsresult status, nsIProxyInfo* pi) { + mStatus = status; + mProxyInfo = pi; + } + + NS_IMETHOD Run() override { + if (mCallback) DoCallback(); + return NS_OK; + } + + NS_IMETHOD Cancel(nsresult reason) override { + NS_ENSURE_ARG(NS_FAILED(reason)); + + if (mAsyncFilterApplier) { + mAsyncFilterApplier->Cancel(reason); + } + + // If we've already called DoCallback then, nothing more to do. + if (!mCallback) return NS_OK; + + SetResult(reason, nullptr); + return DispatchCallback(); + } + + nsresult DispatchCallback() { + if (mDispatched) // Only need to dispatch once + return NS_OK; + + nsresult rv = NS_DispatchToCurrentThread(this); + if (NS_FAILED(rv)) + NS_WARNING("unable to dispatch callback event"); + else { + mDispatched = true; + return NS_OK; + } + + mCallback = nullptr; // break possible reference cycle + return rv; + } + + private: + // Called asynchronously, so we do not need to post another PLEvent + // before calling DoCallback. + void OnQueryComplete(nsresult status, const nsACString& pacString, + const nsACString& newPACURL) override { + // If we've already called DoCallback then, nothing more to do. + if (!mCallback) return; + + // Provided we haven't been canceled... + if (mStatus == NS_OK) { + mStatus = status; + mPACString = pacString; + mPACURL = newPACURL; + } + + // In the cancelation case, we may still have another PLEvent in + // the queue that wants to call DoCallback. No need to wait for + // it, just run the callback now. + DoCallback(); + } + + void DoCallback() { + bool pacAvailable = true; + if (mStatus == NS_ERROR_NOT_AVAILABLE && !mProxyInfo) { + // If the PAC service is not avail (e.g. failed pac load + // or shutdown) then we will be going direct. Make that + // mapping now so that any filters are still applied. + mPACString = "DIRECT;"_ns; + mStatus = NS_OK; + + LOG(("pac not available, use DIRECT\n")); + pacAvailable = false; + } + + // Generate proxy info from the PAC string if appropriate + if (NS_SUCCEEDED(mStatus) && !mProxyInfo && !mPACString.IsEmpty()) { + mPPS->ProcessPACString(mPACString, mResolveFlags, + getter_AddRefs(mProxyInfo)); + nsCOMPtr<nsIURI> proxyURI; + GetProxyURI(mChannel, getter_AddRefs(proxyURI)); + + // Now apply proxy filters + nsProtocolInfo info; + mStatus = mPPS->GetProtocolInfo(proxyURI, &info); + + auto consumeFiltersResult = [pacAvailable](nsAsyncResolveRequest* self, + nsIProxyInfo* pi, + bool async) -> nsresult { + LOG(("DoCallback::consumeFiltersResult this=%p, pi=%p, async=%d", self, + pi, async)); + + self->mProxyInfo = pi; + + if (pacAvailable) { + // if !pacAvailable, it was already logged above + LOG(("pac thread callback %s\n", self->mPACString.get())); + } + + if (NS_SUCCEEDED(self->mStatus)) { + self->mPPS->MaybeDisableDNSPrefetch(self->mProxyInfo); + } + + self->EnsureResolveFlagsMatch(); + self->mCallback->OnProxyAvailable(self, self->mChannel, + self->mProxyInfo, self->mStatus); + + return NS_OK; + }; + + if (NS_SUCCEEDED(mStatus)) { + mAsyncFilterApplier = new AsyncApplyFilters(info, consumeFiltersResult); + // This may call consumeFiltersResult() directly. + mAsyncFilterApplier->AsyncProcess(this); + return; + } + + consumeFiltersResult(this, nullptr, false); + } else if (NS_SUCCEEDED(mStatus) && !mPACURL.IsEmpty()) { + LOG(("pac thread callback indicates new pac file load\n")); + + nsCOMPtr<nsIURI> proxyURI; + GetProxyURI(mChannel, getter_AddRefs(proxyURI)); + + // trigger load of new pac url + nsresult rv = mPPS->ConfigureFromPAC(mPACURL, false); + if (NS_SUCCEEDED(rv)) { + // now that the load is triggered, we can resubmit the query + RefPtr<nsAsyncResolveRequest> newRequest = + new nsAsyncResolveRequest(mPPS, mChannel, mResolveFlags, mCallback); + rv = mPPS->mPACMan->AsyncGetProxyForURI(proxyURI, newRequest, + mResolveFlags, true); + } + + if (NS_FAILED(rv)) + mCallback->OnProxyAvailable(this, mChannel, nullptr, rv); + + // do not call onproxyavailable() in SUCCESS case - the newRequest will + // take care of that + } else { + LOG(("pac thread callback did not provide information %" PRIX32 "\n", + static_cast<uint32_t>(mStatus))); + if (NS_SUCCEEDED(mStatus)) mPPS->MaybeDisableDNSPrefetch(mProxyInfo); + EnsureResolveFlagsMatch(); + mCallback->OnProxyAvailable(this, mChannel, mProxyInfo, mStatus); + } + + // We are on the main thread now and don't need these any more so + // release them to avoid having to proxy them back to the main thread + // in the dtor + mCallback = nullptr; // in case the callback holds an owning ref to us + mPPS = nullptr; + mXPComPPS = nullptr; + mChannel = nullptr; + mProxyInfo = nullptr; + } + + private: + nsresult mStatus; + nsCString mPACString; + nsCString mPACURL; + bool mDispatched; + uint32_t mResolveFlags; + + nsProtocolProxyService* mPPS; + nsCOMPtr<nsIProtocolProxyService> mXPComPPS; + nsCOMPtr<nsIChannel> mChannel; + nsCOMPtr<nsIProtocolProxyCallback> mCallback; + nsCOMPtr<nsIProxyInfo> mProxyInfo; + + RefPtr<AsyncApplyFilters> mAsyncFilterApplier; +}; + +NS_IMPL_ISUPPORTS(nsAsyncResolveRequest, nsICancelable, nsIRunnable) + +NS_IMPL_ISUPPORTS(nsAsyncResolveRequest::AsyncApplyFilters, + nsIProxyProtocolFilterResult, nsICancelable, nsIRunnable) + +nsAsyncResolveRequest::AsyncApplyFilters::AsyncApplyFilters( + nsProtocolInfo& aInfo, Callback const& aCallback) + : mInfo(aInfo), + mCallback(aCallback), + mNextFilterIndex(0), + mProcessingInLoop(false), + mFilterCalledBack(false) { + LOG(("AsyncApplyFilters %p", this)); +} + +nsAsyncResolveRequest::AsyncApplyFilters::~AsyncApplyFilters() { + LOG(("~AsyncApplyFilters %p", this)); + + MOZ_ASSERT(!mRequest); + MOZ_ASSERT(!mProxyInfo); + MOZ_ASSERT(!mFiltersCopy.Length()); +} + +nsresult nsAsyncResolveRequest::AsyncApplyFilters::AsyncProcess( + nsAsyncResolveRequest* aRequest) { + LOG(("AsyncApplyFilters::AsyncProcess %p for req %p", this, aRequest)); + + MOZ_ASSERT(!mRequest, "AsyncApplyFilters started more than once!"); + + if (!(mInfo.flags & nsIProtocolHandler::ALLOWS_PROXY)) { + // Calling the callback directly (not via Finish()) since we + // don't want to prune. + return mCallback(aRequest, aRequest->mProxyInfo, false); + } + + mProcessingThread = NS_GetCurrentThread(); + + mRequest = aRequest; + mProxyInfo = aRequest->mProxyInfo; + + aRequest->mPPS->CopyFilters(mFiltersCopy); + + // We want to give filters a chance to process in a single loop to prevent + // any current-thread dispatch delays when those are not needed. + // This code is rather "loopy" than "recursive" to prevent long stack traces. + do { + MOZ_ASSERT(!mProcessingInLoop); + + mozilla::AutoRestore<bool> restore(mProcessingInLoop); + mProcessingInLoop = true; + + nsresult rv = ProcessNextFilter(); + if (NS_FAILED(rv)) { + return rv; + } + } while (mFilterCalledBack); + + return NS_OK; +} + +nsresult nsAsyncResolveRequest::AsyncApplyFilters::ProcessNextFilter() { + LOG(("AsyncApplyFilters::ProcessNextFilter %p ENTER pi=%p", this, + mProxyInfo.get())); + + RefPtr<FilterLink> filter; + do { + mFilterCalledBack = false; + + if (!mRequest) { + // We got canceled + LOG((" canceled")); + return NS_OK; // should we let the consumer know? + } + + if (mNextFilterIndex == mFiltersCopy.Length()) { + return Finish(); + } + + filter = mFiltersCopy[mNextFilterIndex++]; + + // Loop until a call to a filter succeeded. Other option is to recurse + // but that would waste stack trace when a number of filters gets registered + // and all from some reason tend to fail. + // The !mFilterCalledBack part of the condition is there to protect us from + // calling on another filter when the current one managed to call back and + // then threw. We already have the result so take it and use it since + // the next filter will be processed by the root loop or a call to + // ProcessNextFilter has already been dispatched to this thread. + LOG((" calling filter %p pi=%p", filter.get(), mProxyInfo.get())); + } while (!mRequest->mPPS->ApplyFilter(filter, mRequest->mChannel, mInfo, + mProxyInfo, this) && + !mFilterCalledBack); + + LOG(("AsyncApplyFilters::ProcessNextFilter %p LEAVE pi=%p", this, + mProxyInfo.get())); + return NS_OK; +} + +NS_IMETHODIMP +nsAsyncResolveRequest::AsyncApplyFilters::OnProxyFilterResult( + nsIProxyInfo* aProxyInfo) { + LOG(("AsyncApplyFilters::OnProxyFilterResult %p pi=%p", this, aProxyInfo)); + + MOZ_ASSERT(mProcessingThread && mProcessingThread->IsOnCurrentThread()); + MOZ_ASSERT(!mFilterCalledBack); + + if (mFilterCalledBack) { + LOG((" duplicate notification?")); + return NS_OK; + } + + mFilterCalledBack = true; + + if (!mRequest) { + // We got canceled + LOG((" canceled")); + return NS_OK; + } + + mProxyInfo = aProxyInfo; + + if (mProcessingInLoop) { + // No need to call/dispatch ProcessNextFilter(), we are in a control + // loop that will do this for us and save recursion/dispatching. + LOG((" in a root loop")); + return NS_OK; + } + + if (mNextFilterIndex == mFiltersCopy.Length()) { + // We are done, all filters have been called on! + Finish(); + return NS_OK; + } + + // Redispatch, since we don't want long stacks when filters respond + // synchronously. + LOG((" redispatching")); + NS_DispatchToCurrentThread(this); + return NS_OK; +} + +NS_IMETHODIMP +nsAsyncResolveRequest::AsyncApplyFilters::Run() { + LOG(("AsyncApplyFilters::Run %p", this)); + + MOZ_ASSERT(mProcessingThread && mProcessingThread->IsOnCurrentThread()); + + ProcessNextFilter(); + return NS_OK; +} + +nsresult nsAsyncResolveRequest::AsyncApplyFilters::Finish() { + LOG(("AsyncApplyFilters::Finish %p pi=%p", this, mProxyInfo.get())); + + MOZ_ASSERT(mRequest); + + mFiltersCopy.Clear(); + + RefPtr<nsAsyncResolveRequest> request; + request.swap(mRequest); + + nsCOMPtr<nsIProxyInfo> pi; + pi.swap(mProxyInfo); + + request->mPPS->PruneProxyInfo(mInfo, pi); + return mCallback(request, pi, !mProcessingInLoop); +} + +NS_IMETHODIMP +nsAsyncResolveRequest::AsyncApplyFilters::Cancel(nsresult reason) { + LOG(("AsyncApplyFilters::Cancel %p", this)); + + MOZ_ASSERT(mProcessingThread && mProcessingThread->IsOnCurrentThread()); + + // This will be called only from inside the request, so don't call + // its's callback. Dropping the members means we simply break the cycle. + mFiltersCopy.Clear(); + mProxyInfo = nullptr; + mRequest = nullptr; + + return NS_OK; +} + +// Bug 1366133: make GetPACURI off-main-thread since it may hang on Windows +// platform +class AsyncGetPACURIRequest final : public nsIRunnable { + public: + NS_DECL_THREADSAFE_ISUPPORTS + + using CallbackFunc = nsresult (nsProtocolProxyService::*)(bool, bool, + nsresult, + const nsACString&); + + AsyncGetPACURIRequest(nsProtocolProxyService* aService, + CallbackFunc aCallback, + nsISystemProxySettings* aSystemProxySettings, + bool aMainThreadOnly, bool aForceReload, + bool aResetPACThread) + : mIsMainThreadOnly(aMainThreadOnly), + mService(aService), + mServiceHolder(do_QueryObject(aService)), + mCallback(aCallback), + mSystemProxySettings(aSystemProxySettings), + mForceReload(aForceReload), + mResetPACThread(aResetPACThread) { + MOZ_ASSERT(NS_IsMainThread()); + Unused << mIsMainThreadOnly; + } + + NS_IMETHOD Run() override { + MOZ_ASSERT(NS_IsMainThread() == mIsMainThreadOnly); + + nsCString pacUri; + nsresult rv = mSystemProxySettings->GetPACURI(pacUri); + + nsCOMPtr<nsIRunnable> event = + NewNonOwningCancelableRunnableMethod<bool, bool, nsresult, nsCString>( + "AsyncGetPACURIRequestCallback", mService, mCallback, mForceReload, + mResetPACThread, rv, pacUri); + + return NS_DispatchToMainThread(event); + } + + private: + ~AsyncGetPACURIRequest() { + NS_ReleaseOnMainThread("AsyncGetPACURIRequest::mServiceHolder", + mServiceHolder.forget()); + } + + bool mIsMainThreadOnly; + + nsProtocolProxyService* mService; // ref-count is hold by mServiceHolder + nsCOMPtr<nsIProtocolProxyService2> mServiceHolder; + CallbackFunc mCallback; + nsCOMPtr<nsISystemProxySettings> mSystemProxySettings; + + bool mForceReload; + bool mResetPACThread; +}; + +NS_IMPL_ISUPPORTS(AsyncGetPACURIRequest, nsIRunnable) + +//---------------------------------------------------------------------------- + +// +// apply mask to address (zeros out excluded bits). +// +// NOTE: we do the byte swapping here to minimize overall swapping. +// +static void proxy_MaskIPv6Addr(PRIPv6Addr& addr, uint16_t mask_len) { + if (mask_len == 128) return; + + if (mask_len > 96) { + addr.pr_s6_addr32[3] = + PR_htonl(PR_ntohl(addr.pr_s6_addr32[3]) & (~0uL << (128 - mask_len))); + } else if (mask_len > 64) { + addr.pr_s6_addr32[3] = 0; + addr.pr_s6_addr32[2] = + PR_htonl(PR_ntohl(addr.pr_s6_addr32[2]) & (~0uL << (96 - mask_len))); + } else if (mask_len > 32) { + addr.pr_s6_addr32[3] = 0; + addr.pr_s6_addr32[2] = 0; + addr.pr_s6_addr32[1] = + PR_htonl(PR_ntohl(addr.pr_s6_addr32[1]) & (~0uL << (64 - mask_len))); + } else { + addr.pr_s6_addr32[3] = 0; + addr.pr_s6_addr32[2] = 0; + addr.pr_s6_addr32[1] = 0; + addr.pr_s6_addr32[0] = + PR_htonl(PR_ntohl(addr.pr_s6_addr32[0]) & (~0uL << (32 - mask_len))); + } +} + +static void proxy_GetStringPref(nsIPrefBranch* aPrefBranch, const char* aPref, + nsCString& aResult) { + nsAutoCString temp; + nsresult rv = aPrefBranch->GetCharPref(aPref, temp); + if (NS_FAILED(rv)) + aResult.Truncate(); + else { + aResult.Assign(temp); + // all of our string prefs are hostnames, so we should remove any + // whitespace characters that the user might have unknowingly entered. + aResult.StripWhitespace(); + } +} + +static void proxy_GetIntPref(nsIPrefBranch* aPrefBranch, const char* aPref, + int32_t& aResult) { + int32_t temp; + nsresult rv = aPrefBranch->GetIntPref(aPref, &temp); + if (NS_FAILED(rv)) + aResult = -1; + else + aResult = temp; +} + +static void proxy_GetBoolPref(nsIPrefBranch* aPrefBranch, const char* aPref, + bool& aResult) { + bool temp; + nsresult rv = aPrefBranch->GetBoolPref(aPref, &temp); + if (NS_FAILED(rv)) + aResult = false; + else + aResult = temp; +} + +//---------------------------------------------------------------------------- + +static const int32_t PROXYCONFIG_DIRECT4X = 3; +static const int32_t PROXYCONFIG_COUNT = 6; + +NS_IMPL_ADDREF(nsProtocolProxyService) +NS_IMPL_RELEASE(nsProtocolProxyService) +NS_IMPL_CLASSINFO(nsProtocolProxyService, nullptr, nsIClassInfo::SINGLETON, + NS_PROTOCOLPROXYSERVICE_CID) + +// NS_IMPL_QUERY_INTERFACE_CI with the nsProtocolProxyService QI change +NS_INTERFACE_MAP_BEGIN(nsProtocolProxyService) + NS_INTERFACE_MAP_ENTRY(nsIProtocolProxyService) + NS_INTERFACE_MAP_ENTRY(nsIProtocolProxyService2) + NS_INTERFACE_MAP_ENTRY(nsIObserver) + NS_INTERFACE_MAP_ENTRY_CONCRETE(nsProtocolProxyService) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIProtocolProxyService) + NS_IMPL_QUERY_CLASSINFO(nsProtocolProxyService) +NS_INTERFACE_MAP_END + +NS_IMPL_CI_INTERFACE_GETTER(nsProtocolProxyService, nsIProtocolProxyService, + nsIProtocolProxyService2) + +nsProtocolProxyService::nsProtocolProxyService() + : mFilterLocalHosts(false), + mProxyConfig(PROXYCONFIG_DIRECT), + mHTTPProxyPort(-1), + mFTPProxyPort(-1), + mHTTPSProxyPort(-1), + mSOCKSProxyPort(-1), + mSOCKSProxyVersion(4), + mSOCKSProxyRemoteDNS(false), + mProxyOverTLS(true), + mWPADOverDHCPEnabled(false), + mPACMan(nullptr), + mSessionStart(PR_Now()), + mFailedProxyTimeout(30 * 60) // 30 minute default + , + mIsShutdown(false) {} + +nsProtocolProxyService::~nsProtocolProxyService() { + // These should have been cleaned up in our Observe method. + NS_ASSERTION(mHostFiltersArray.Length() == 0 && mFilters.Length() == 0 && + mPACMan == nullptr, + "what happened to xpcom-shutdown?"); +} + +// nsProtocolProxyService methods +nsresult nsProtocolProxyService::Init() { + mProxySettingTarget = do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID); + + // failure to access prefs is non-fatal + nsCOMPtr<nsIPrefBranch> prefBranch = do_GetService(NS_PREFSERVICE_CONTRACTID); + if (prefBranch) { + // monitor proxy prefs + prefBranch->AddObserver(PROXY_PREF_BRANCH, this, false); + + // read all prefs + PrefsChanged(prefBranch, nullptr); + } + + nsCOMPtr<nsIObserverService> obs = services::GetObserverService(); + if (obs) { + // register for shutdown notification so we can clean ourselves up + // properly. + obs->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false); + obs->AddObserver(this, NS_NETWORK_LINK_TOPIC, false); + } + + return NS_OK; +} + +// ReloadNetworkPAC() checks if there's a non-networked PAC in use then avoids +// to call ReloadPAC() +nsresult nsProtocolProxyService::ReloadNetworkPAC() { + nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID); + if (!prefs) { + return NS_OK; + } + + int32_t type; + nsresult rv = prefs->GetIntPref(PROXY_PREF("type"), &type); + if (NS_FAILED(rv)) { + return NS_OK; + } + + if (type == PROXYCONFIG_PAC) { + nsAutoCString pacSpec; + prefs->GetCharPref(PROXY_PREF("autoconfig_url"), pacSpec); + if (!pacSpec.IsEmpty()) { + nsCOMPtr<nsIURI> pacURI; + rv = NS_NewURI(getter_AddRefs(pacURI), pacSpec); + if (!NS_SUCCEEDED(rv)) { + return rv; + } + + nsProtocolInfo pac; + rv = GetProtocolInfo(pacURI, &pac); + if (!NS_SUCCEEDED(rv)) { + return rv; + } + + if (!pac.scheme.EqualsLiteral("file") && + !pac.scheme.EqualsLiteral("data")) { + LOG((": received network changed event, reload PAC")); + ReloadPAC(); + } + } + } else if ((type == PROXYCONFIG_WPAD) || (type == PROXYCONFIG_SYSTEM)) { + ReloadPAC(); + } + + return NS_OK; +} + +nsresult nsProtocolProxyService::AsyncConfigureFromPAC(bool aForceReload, + bool aResetPACThread) { + MOZ_ASSERT(NS_IsMainThread()); + + bool mainThreadOnly; + nsresult rv = mSystemProxySettings->GetMainThreadOnly(&mainThreadOnly); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + nsCOMPtr<nsIRunnable> req = new AsyncGetPACURIRequest( + this, &nsProtocolProxyService::OnAsyncGetPACURI, mSystemProxySettings, + mainThreadOnly, aForceReload, aResetPACThread); + + if (mainThreadOnly) { + return req->Run(); + } + + if (NS_WARN_IF(!mProxySettingTarget)) { + return NS_ERROR_NOT_INITIALIZED; + } + return mProxySettingTarget->Dispatch(req, nsIEventTarget::DISPATCH_NORMAL); +} + +nsresult nsProtocolProxyService::OnAsyncGetPACURI(bool aForceReload, + bool aResetPACThread, + nsresult aResult, + const nsACString& aUri) { + MOZ_ASSERT(NS_IsMainThread()); + + if (aResetPACThread) { + ResetPACThread(); + } + + if (NS_SUCCEEDED(aResult) && !aUri.IsEmpty()) { + ConfigureFromPAC(PromiseFlatCString(aUri), aForceReload); + } + + return NS_OK; +} + +NS_IMETHODIMP +nsProtocolProxyService::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) { + if (strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0) { + mIsShutdown = true; + // cleanup + mHostFiltersArray.Clear(); + mFilters.Clear(); + + if (mPACMan) { + mPACMan->Shutdown(); + mPACMan = nullptr; + } + + if (mProxySettingTarget) { + mProxySettingTarget = nullptr; + } + + nsCOMPtr<nsIObserverService> obs = services::GetObserverService(); + if (obs) { + obs->RemoveObserver(this, NS_NETWORK_LINK_TOPIC); + obs->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID); + } + + } else if (strcmp(aTopic, NS_NETWORK_LINK_TOPIC) == 0) { + nsCString converted = NS_ConvertUTF16toUTF8(aData); + const char* state = converted.get(); + if (!strcmp(state, NS_NETWORK_LINK_DATA_CHANGED)) { + ReloadNetworkPAC(); + } + } else { + NS_ASSERTION(strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID) == 0, + "what is this random observer event?"); + nsCOMPtr<nsIPrefBranch> prefs = do_QueryInterface(aSubject); + if (prefs) PrefsChanged(prefs, NS_LossyConvertUTF16toASCII(aData).get()); + } + return NS_OK; +} + +void nsProtocolProxyService::PrefsChanged(nsIPrefBranch* prefBranch, + const char* pref) { + nsresult rv = NS_OK; + bool reloadPAC = false; + nsAutoCString tempString; + + if (!pref || !strcmp(pref, PROXY_PREF("type"))) { + int32_t type = -1; + rv = prefBranch->GetIntPref(PROXY_PREF("type"), &type); + if (NS_SUCCEEDED(rv)) { + // bug 115720 - for ns4.x backwards compatibility + if (type == PROXYCONFIG_DIRECT4X) { + type = PROXYCONFIG_DIRECT; + // Reset the type so that the dialog looks correct, and we + // don't have to handle this case everywhere else + // I'm paranoid about a loop of some sort - only do this + // if we're enumerating all prefs, and ignore any error + if (!pref) prefBranch->SetIntPref(PROXY_PREF("type"), type); + } else if (type >= PROXYCONFIG_COUNT) { + LOG(("unknown proxy type: %" PRId32 "; assuming direct\n", type)); + type = PROXYCONFIG_DIRECT; + } + mProxyConfig = type; + reloadPAC = true; + } + + if (mProxyConfig == PROXYCONFIG_SYSTEM) { + mSystemProxySettings = do_GetService(NS_SYSTEMPROXYSETTINGS_CONTRACTID); + if (!mSystemProxySettings) mProxyConfig = PROXYCONFIG_DIRECT; + ResetPACThread(); + } else { + if (mSystemProxySettings) { + mSystemProxySettings = nullptr; + ResetPACThread(); + } + } + } + + if (!pref || !strcmp(pref, PROXY_PREF("http"))) + proxy_GetStringPref(prefBranch, PROXY_PREF("http"), mHTTPProxyHost); + + if (!pref || !strcmp(pref, PROXY_PREF("http_port"))) + proxy_GetIntPref(prefBranch, PROXY_PREF("http_port"), mHTTPProxyPort); + + if (!pref || !strcmp(pref, PROXY_PREF("ssl"))) + proxy_GetStringPref(prefBranch, PROXY_PREF("ssl"), mHTTPSProxyHost); + + if (!pref || !strcmp(pref, PROXY_PREF("ssl_port"))) + proxy_GetIntPref(prefBranch, PROXY_PREF("ssl_port"), mHTTPSProxyPort); + + if (!pref || !strcmp(pref, PROXY_PREF("ftp"))) + proxy_GetStringPref(prefBranch, PROXY_PREF("ftp"), mFTPProxyHost); + + if (!pref || !strcmp(pref, PROXY_PREF("ftp_port"))) + proxy_GetIntPref(prefBranch, PROXY_PREF("ftp_port"), mFTPProxyPort); + + if (!pref || !strcmp(pref, PROXY_PREF("socks"))) + proxy_GetStringPref(prefBranch, PROXY_PREF("socks"), mSOCKSProxyTarget); + + if (!pref || !strcmp(pref, PROXY_PREF("socks_port"))) + proxy_GetIntPref(prefBranch, PROXY_PREF("socks_port"), mSOCKSProxyPort); + + if (!pref || !strcmp(pref, PROXY_PREF("socks_version"))) { + int32_t version; + proxy_GetIntPref(prefBranch, PROXY_PREF("socks_version"), version); + // make sure this preference value remains sane + if (version == 5) + mSOCKSProxyVersion = 5; + else + mSOCKSProxyVersion = 4; + } + + if (!pref || !strcmp(pref, PROXY_PREF("socks_remote_dns"))) + proxy_GetBoolPref(prefBranch, PROXY_PREF("socks_remote_dns"), + mSOCKSProxyRemoteDNS); + + if (!pref || !strcmp(pref, PROXY_PREF("proxy_over_tls"))) { + proxy_GetBoolPref(prefBranch, PROXY_PREF("proxy_over_tls"), mProxyOverTLS); + } + + if (!pref || !strcmp(pref, PROXY_PREF("enable_wpad_over_dhcp"))) { + proxy_GetBoolPref(prefBranch, PROXY_PREF("enable_wpad_over_dhcp"), + mWPADOverDHCPEnabled); + reloadPAC = reloadPAC || mProxyConfig == PROXYCONFIG_WPAD; + } + + if (!pref || !strcmp(pref, PROXY_PREF("failover_timeout"))) + proxy_GetIntPref(prefBranch, PROXY_PREF("failover_timeout"), + mFailedProxyTimeout); + + if (!pref || !strcmp(pref, PROXY_PREF("no_proxies_on"))) { + rv = prefBranch->GetCharPref(PROXY_PREF("no_proxies_on"), tempString); + if (NS_SUCCEEDED(rv)) LoadHostFilters(tempString); + } + + // We're done if not using something that could give us a PAC URL + // (PAC, WPAD or System) + if (mProxyConfig != PROXYCONFIG_PAC && mProxyConfig != PROXYCONFIG_WPAD && + mProxyConfig != PROXYCONFIG_SYSTEM) + return; + + // OK, we need to reload the PAC file if: + // 1) network.proxy.type changed, or + // 2) network.proxy.autoconfig_url changed and PAC is configured + + if (!pref || !strcmp(pref, PROXY_PREF("autoconfig_url"))) reloadPAC = true; + + if (reloadPAC) { + tempString.Truncate(); + if (mProxyConfig == PROXYCONFIG_PAC) { + prefBranch->GetCharPref(PROXY_PREF("autoconfig_url"), tempString); + if (mPACMan && !mPACMan->IsPACURI(tempString)) { + LOG(("PAC Thread URI Changed - Reset Pac Thread")); + ResetPACThread(); + } + } else if (mProxyConfig == PROXYCONFIG_WPAD) { + LOG(("Auto-detecting proxy - Reset Pac Thread")); + ResetPACThread(); + } else if (mSystemProxySettings) { + // Get System Proxy settings if available + AsyncConfigureFromPAC(false, false); + } + if (!tempString.IsEmpty() || mProxyConfig == PROXYCONFIG_WPAD) { + ConfigureFromPAC(tempString, false); + } + } +} + +bool nsProtocolProxyService::CanUseProxy(nsIURI* aURI, int32_t defaultPort) { + int32_t port; + nsAutoCString host; + + nsresult rv = aURI->GetAsciiHost(host); + if (NS_FAILED(rv) || host.IsEmpty()) return false; + + rv = aURI->GetPort(&port); + if (NS_FAILED(rv)) return false; + if (port == -1) port = defaultPort; + + PRNetAddr addr; + bool is_ipaddr = (PR_StringToNetAddr(host.get(), &addr) == PR_SUCCESS); + + PRIPv6Addr ipv6; + if (is_ipaddr) { + // convert parsed address to IPv6 + if (addr.raw.family == PR_AF_INET) { + // convert to IPv4-mapped address + PR_ConvertIPv4AddrToIPv6(addr.inet.ip, &ipv6); + } else if (addr.raw.family == PR_AF_INET6) { + // copy the address + memcpy(&ipv6, &addr.ipv6.ip, sizeof(PRIPv6Addr)); + } else { + NS_WARNING("unknown address family"); + return true; // allow proxying + } + } + + // Don't use proxy for local hosts (plain hostname, no dots) + if ((!is_ipaddr && mFilterLocalHosts && !host.Contains('.')) || + // This method detects if we have network.proxy.allow_hijacking_localhost + // pref enabled. If it's true then this method will always return false + // otherwise it returns true if the host matches an address that's + // hardcoded to the loopback address. + (!StaticPrefs::network_proxy_allow_hijacking_localhost() && + nsMixedContentBlocker::IsPotentiallyTrustworthyLoopbackHost(host))) { + LOG(("Not using proxy for this local host [%s]!\n", host.get())); + return false; // don't allow proxying + } + + int32_t index = -1; + while (++index < int32_t(mHostFiltersArray.Length())) { + const auto& hinfo = mHostFiltersArray[index]; + + if (is_ipaddr != hinfo->is_ipaddr) continue; + if (hinfo->port && hinfo->port != port) continue; + + if (is_ipaddr) { + // generate masked version of target IPv6 address + PRIPv6Addr masked; + memcpy(&masked, &ipv6, sizeof(PRIPv6Addr)); + proxy_MaskIPv6Addr(masked, hinfo->ip.mask_len); + + // check for a match + if (memcmp(&masked, &hinfo->ip.addr, sizeof(PRIPv6Addr)) == 0) + return false; // proxy disallowed + } else { + uint32_t host_len = host.Length(); + uint32_t filter_host_len = hinfo->name.host_len; + + if (host_len >= filter_host_len) { + // + // compare last |filter_host_len| bytes of target hostname. + // + const char* host_tail = host.get() + host_len - filter_host_len; + if (!PL_strncasecmp(host_tail, hinfo->name.host, filter_host_len)) { + // If the tail of the host string matches the filter + + if (filter_host_len > 0 && hinfo->name.host[0] == '.') { + // If the filter was of the form .foo.bar.tld, all such + // matches are correct + return false; // proxy disallowed + } + + // abc-def.example.org should not match def.example.org + // however, *.def.example.org should match .def.example.org + // We check that the filter doesn't start with a `.`. If it does, + // then the strncasecmp above should suffice. If it doesn't, + // then we should only consider it a match if the strncasecmp happened + // at a subdomain boundary + if (host_len > filter_host_len && *(host_tail - 1) == '.') { + // If the host was something.foo.bar.tld and the filter + // was foo.bar.tld, it's still a match. + // the character right before the tail must be a + // `.` for this to work + return false; // proxy disallowed + } + + if (host_len == filter_host_len) { + // If the host and filter are of the same length, + // they should match + return false; // proxy disallowed + } + } + } + } + } + return true; +} + +// kProxyType\* may be referred to externally in +// nsProxyInfo in order to compare by string pointer +const char kProxyType_HTTP[] = "http"; +const char kProxyType_HTTPS[] = "https"; +const char kProxyType_PROXY[] = "proxy"; +const char kProxyType_SOCKS[] = "socks"; +const char kProxyType_SOCKS4[] = "socks4"; +const char kProxyType_SOCKS5[] = "socks5"; +const char kProxyType_DIRECT[] = "direct"; + +const char* nsProtocolProxyService::ExtractProxyInfo(const char* start, + uint32_t aResolveFlags, + nsProxyInfo** result) { + *result = nullptr; + uint32_t flags = 0; + + // see BNF in ProxyAutoConfig.h and notes in nsISystemProxySettings.idl + + // find end of proxy info delimiter + const char* end = start; + while (*end && *end != ';') ++end; + + // find end of proxy type delimiter + const char* sp = start; + while (sp < end && *sp != ' ' && *sp != '\t') ++sp; + + uint32_t len = sp - start; + const char* type = nullptr; + switch (len) { + case 4: + if (PL_strncasecmp(start, kProxyType_HTTP, 4) == 0) { + type = kProxyType_HTTP; + } + break; + case 5: + if (PL_strncasecmp(start, kProxyType_PROXY, 5) == 0) { + type = kProxyType_HTTP; + } else if (PL_strncasecmp(start, kProxyType_SOCKS, 5) == 0) { + type = kProxyType_SOCKS4; // assume v4 for 4x compat + } else if (PL_strncasecmp(start, kProxyType_HTTPS, 5) == 0) { + type = kProxyType_HTTPS; + } + break; + case 6: + if (PL_strncasecmp(start, kProxyType_DIRECT, 6) == 0) + type = kProxyType_DIRECT; + else if (PL_strncasecmp(start, kProxyType_SOCKS4, 6) == 0) + type = kProxyType_SOCKS4; + else if (PL_strncasecmp(start, kProxyType_SOCKS5, 6) == 0) + // map "SOCKS5" to "socks" to match contract-id of registered + // SOCKS-v5 socket provider. + type = kProxyType_SOCKS; + break; + } + if (type) { + int32_t port = -1; + + // If it's a SOCKS5 proxy, do name resolution on the server side. + // We could use this with SOCKS4a servers too, but they might not + // support it. + if (type == kProxyType_SOCKS || mSOCKSProxyRemoteDNS) + flags |= nsIProxyInfo::TRANSPARENT_PROXY_RESOLVES_HOST; + + // extract host:port + start = sp; + while ((*start == ' ' || *start == '\t') && start < end) start++; + + // port defaults + if (type == kProxyType_HTTP) { + port = 80; + } else if (type == kProxyType_HTTPS) { + port = 443; + } else { + port = 1080; + } + + RefPtr<nsProxyInfo> pi = new nsProxyInfo(); + pi->mType = type; + pi->mFlags = flags; + pi->mResolveFlags = aResolveFlags; + pi->mTimeout = mFailedProxyTimeout; + + // www.foo.com:8080 and http://www.foo.com:8080 + nsDependentCSubstring maybeURL(start, end - start); + nsCOMPtr<nsIURI> pacURI; + + nsAutoCString urlHost; + // First assume the scheme is present, e.g. http://www.example.com:8080 + if (NS_FAILED(NS_NewURI(getter_AddRefs(pacURI), maybeURL)) || + NS_FAILED(pacURI->GetAsciiHost(urlHost)) || urlHost.IsEmpty()) { + // It isn't, assume www.example.com:8080 + maybeURL.Insert("http://", 0); + + if (NS_SUCCEEDED(NS_NewURI(getter_AddRefs(pacURI), maybeURL))) { + pacURI->GetAsciiHost(urlHost); + } + } + + if (!urlHost.IsEmpty()) { + pi->mHost = urlHost; + + int32_t tPort; + if (NS_SUCCEEDED(pacURI->GetPort(&tPort)) && tPort != -1) { + port = tPort; + } + pi->mPort = port; + } + + pi.forget(result); + } + + while (*end == ';' || *end == ' ' || *end == '\t') ++end; + return end; +} + +void nsProtocolProxyService::GetProxyKey(nsProxyInfo* pi, nsCString& key) { + key.AssignASCII(pi->mType); + if (!pi->mHost.IsEmpty()) { + key.Append(' '); + key.Append(pi->mHost); + key.Append(':'); + key.AppendInt(pi->mPort); + } +} + +uint32_t nsProtocolProxyService::SecondsSinceSessionStart() { + PRTime now = PR_Now(); + + // get time elapsed since session start + int64_t diff = now - mSessionStart; + + // convert microseconds to seconds + diff /= PR_USEC_PER_SEC; + + // return converted 32 bit value + return uint32_t(diff); +} + +void nsProtocolProxyService::EnableProxy(nsProxyInfo* pi) { + nsAutoCString key; + GetProxyKey(pi, key); + mFailedProxies.Remove(key); +} + +void nsProtocolProxyService::DisableProxy(nsProxyInfo* pi) { + nsAutoCString key; + GetProxyKey(pi, key); + + uint32_t dsec = SecondsSinceSessionStart(); + + // Add timeout to interval (this is the time when the proxy can + // be tried again). + dsec += pi->mTimeout; + + // NOTE: The classic codebase would increase the timeout value + // incrementally each time a subsequent failure occurred. + // We could do the same, but it would require that we not + // remove proxy entries in IsProxyDisabled or otherwise + // change the way we are recording disabled proxies. + // Simpler is probably better for now, and at least the + // user can tune the timeout setting via preferences. + + LOG(("DisableProxy %s %d\n", key.get(), dsec)); + + // If this fails, oh well... means we don't have enough memory + // to remember the failed proxy. + mFailedProxies.Put(key, dsec); +} + +bool nsProtocolProxyService::IsProxyDisabled(nsProxyInfo* pi) { + nsAutoCString key; + GetProxyKey(pi, key); + + uint32_t val; + if (!mFailedProxies.Get(key, &val)) return false; + + uint32_t dsec = SecondsSinceSessionStart(); + + // if time passed has exceeded interval, then try proxy again. + if (dsec > val) { + mFailedProxies.Remove(key); + return false; + } + + return true; +} + +nsresult nsProtocolProxyService::SetupPACThread( + nsISerialEventTarget* mainThreadEventTarget) { + if (mIsShutdown) { + return NS_ERROR_FAILURE; + } + + if (mPACMan) return NS_OK; + + mPACMan = new nsPACMan(mainThreadEventTarget); + + bool mainThreadOnly; + nsresult rv; + if (mSystemProxySettings && + NS_SUCCEEDED(mSystemProxySettings->GetMainThreadOnly(&mainThreadOnly)) && + !mainThreadOnly) { + rv = mPACMan->Init(mSystemProxySettings); + } else { + rv = mPACMan->Init(nullptr); + } + if (NS_FAILED(rv)) { + mPACMan->Shutdown(); + mPACMan = nullptr; + } + return rv; +} + +nsresult nsProtocolProxyService::ResetPACThread() { + if (!mPACMan) return NS_OK; + + mPACMan->Shutdown(); + mPACMan = nullptr; + return SetupPACThread(); +} + +nsresult nsProtocolProxyService::ConfigureFromPAC(const nsCString& spec, + bool forceReload) { + nsresult rv = SetupPACThread(); + NS_ENSURE_SUCCESS(rv, rv); + + bool autodetect = spec.IsEmpty(); + if (!forceReload && ((!autodetect && mPACMan->IsPACURI(spec)) || + (autodetect && mPACMan->IsUsingWPAD()))) { + return NS_OK; + } + + mFailedProxies.Clear(); + + mPACMan->SetWPADOverDHCPEnabled(mWPADOverDHCPEnabled); + return mPACMan->LoadPACFromURI(spec); +} + +void nsProtocolProxyService::ProcessPACString(const nsCString& pacString, + uint32_t aResolveFlags, + nsIProxyInfo** result) { + if (pacString.IsEmpty()) { + *result = nullptr; + return; + } + + const char* proxies = pacString.get(); + + nsProxyInfo *pi = nullptr, *first = nullptr, *last = nullptr; + while (*proxies) { + proxies = ExtractProxyInfo(proxies, aResolveFlags, &pi); + if (pi && (pi->mType == kProxyType_HTTPS) && !mProxyOverTLS) { + delete pi; + pi = nullptr; + } + + if (pi) { + if (last) { + NS_ASSERTION(last->mNext == nullptr, "leaking nsProxyInfo"); + last->mNext = pi; + } else + first = pi; + last = pi; + } + } + *result = first; +} + +// nsIProtocolProxyService2 +NS_IMETHODIMP +nsProtocolProxyService::ReloadPAC() { + nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID); + if (!prefs) return NS_OK; + + int32_t type; + nsresult rv = prefs->GetIntPref(PROXY_PREF("type"), &type); + if (NS_FAILED(rv)) return NS_OK; + + nsAutoCString pacSpec; + if (type == PROXYCONFIG_PAC) + prefs->GetCharPref(PROXY_PREF("autoconfig_url"), pacSpec); + else if (type == PROXYCONFIG_SYSTEM) { + if (mSystemProxySettings) { + AsyncConfigureFromPAC(true, true); + } else { + ResetPACThread(); + } + } + + if (!pacSpec.IsEmpty() || type == PROXYCONFIG_WPAD) + ConfigureFromPAC(pacSpec, true); + return NS_OK; +} + +// When sync interface is removed this can go away too +// The nsPACManCallback portion of this implementation should be run +// off the main thread, because it uses a condvar for signaling and +// the main thread is blocking on that condvar - +// so call nsPACMan::AsyncGetProxyForURI() with +// a false mainThreadResponse parameter. +class nsAsyncBridgeRequest final : public nsPACManCallback { + NS_DECL_THREADSAFE_ISUPPORTS + + nsAsyncBridgeRequest() + : mMutex("nsDeprecatedCallback"), + mCondVar(mMutex, "nsDeprecatedCallback"), + mStatus(NS_OK), + mCompleted(false) {} + + void OnQueryComplete(nsresult status, const nsACString& pacString, + const nsACString& newPACURL) override { + MutexAutoLock lock(mMutex); + mCompleted = true; + mStatus = status; + mPACString = pacString; + mPACURL = newPACURL; + mCondVar.Notify(); + } + + void Lock() { mMutex.Lock(); } + void Unlock() { mMutex.Unlock(); } + void Wait() { mCondVar.Wait(TimeDuration::FromSeconds(3)); } + + private: + ~nsAsyncBridgeRequest() = default; + + friend class nsProtocolProxyService; + + Mutex mMutex; + CondVar mCondVar; + + nsresult mStatus; + nsCString mPACString; + nsCString mPACURL; + bool mCompleted; +}; +NS_IMPL_ISUPPORTS0(nsAsyncBridgeRequest) + +nsresult nsProtocolProxyService::AsyncResolveInternal( + nsIChannel* channel, uint32_t flags, nsIProtocolProxyCallback* callback, + nsICancelable** result, bool isSyncOK, + nsISerialEventTarget* mainThreadEventTarget) { + NS_ENSURE_ARG_POINTER(channel); + NS_ENSURE_ARG_POINTER(callback); + + nsCOMPtr<nsIURI> uri; + nsresult rv = GetProxyURI(channel, getter_AddRefs(uri)); + if (NS_FAILED(rv)) return rv; + + *result = nullptr; + RefPtr<nsAsyncResolveRequest> ctx = + new nsAsyncResolveRequest(this, channel, flags, callback); + + nsProtocolInfo info; + rv = GetProtocolInfo(uri, &info); + if (NS_FAILED(rv)) return rv; + + nsCOMPtr<nsIProxyInfo> pi; + bool usePACThread; + + // adapt to realtime changes in the system proxy service + if (mProxyConfig == PROXYCONFIG_SYSTEM) { + nsCOMPtr<nsISystemProxySettings> sp2 = + do_GetService(NS_SYSTEMPROXYSETTINGS_CONTRACTID); + if (sp2 != mSystemProxySettings) { + mSystemProxySettings = sp2; + ResetPACThread(); + } + } + + rv = SetupPACThread(mainThreadEventTarget); + if (NS_FAILED(rv)) { + return rv; + } + + // SystemProxySettings and PAC files can block the main thread + // but if neither of them are in use, we can just do the work + // right here and directly invoke the callback + + rv = + Resolve_Internal(channel, info, flags, &usePACThread, getter_AddRefs(pi)); + if (NS_FAILED(rv)) return rv; + + if (!usePACThread || !mPACMan) { + // we can do it locally + rv = ctx->ProcessLocally(info, pi, isSyncOK); + if (NS_SUCCEEDED(rv) && !isSyncOK) { + ctx.forget(result); + } + return rv; + } + + // else kick off a PAC thread query + rv = mPACMan->AsyncGetProxyForURI(uri, ctx, flags, true); + if (NS_SUCCEEDED(rv)) ctx.forget(result); + return rv; +} + +// nsIProtocolProxyService +NS_IMETHODIMP +nsProtocolProxyService::AsyncResolve2( + nsIChannel* channel, uint32_t flags, nsIProtocolProxyCallback* callback, + nsISerialEventTarget* mainThreadEventTarget, nsICancelable** result) { + return AsyncResolveInternal(channel, flags, callback, result, true, + mainThreadEventTarget); +} + +NS_IMETHODIMP +nsProtocolProxyService::AsyncResolve( + nsISupports* channelOrURI, uint32_t flags, + nsIProtocolProxyCallback* callback, + nsISerialEventTarget* mainThreadEventTarget, nsICancelable** result) { + nsresult rv; + // Check if we got a channel: + nsCOMPtr<nsIChannel> channel = do_QueryInterface(channelOrURI); + if (!channel) { + nsCOMPtr<nsIURI> uri = do_QueryInterface(channelOrURI); + if (!uri) { + return NS_ERROR_NO_INTERFACE; + } + + // creating a temporary channel from the URI which is not + // used to perform any network loads, hence its safe to + // use systemPrincipal as the loadingPrincipal. + rv = NS_NewChannel(getter_AddRefs(channel), uri, + nsContentUtils::GetSystemPrincipal(), + nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL, + nsIContentPolicy::TYPE_OTHER); + NS_ENSURE_SUCCESS(rv, rv); + } + + return AsyncResolveInternal(channel, flags, callback, result, false, + mainThreadEventTarget); +} + +NS_IMETHODIMP +nsProtocolProxyService::NewProxyInfo( + const nsACString& aType, const nsACString& aHost, int32_t aPort, + const nsACString& aProxyAuthorizationHeader, + const nsACString& aConnectionIsolationKey, uint32_t aFlags, + uint32_t aFailoverTimeout, nsIProxyInfo* aFailoverProxy, + nsIProxyInfo** aResult) { + return NewProxyInfoWithAuth(aType, aHost, aPort, ""_ns, ""_ns, + aProxyAuthorizationHeader, + aConnectionIsolationKey, aFlags, aFailoverTimeout, + aFailoverProxy, aResult); +} + +NS_IMETHODIMP +nsProtocolProxyService::NewProxyInfoWithAuth( + const nsACString& aType, const nsACString& aHost, int32_t aPort, + const nsACString& aUsername, const nsACString& aPassword, + const nsACString& aProxyAuthorizationHeader, + const nsACString& aConnectionIsolationKey, uint32_t aFlags, + uint32_t aFailoverTimeout, nsIProxyInfo* aFailoverProxy, + nsIProxyInfo** aResult) { + static const char* types[] = {kProxyType_HTTP, kProxyType_HTTPS, + kProxyType_SOCKS, kProxyType_SOCKS4, + kProxyType_DIRECT}; + + // resolve type; this allows us to avoid copying the type string into each + // proxy info instance. we just reference the string literals directly :) + const char* type = nullptr; + for (auto& t : types) { + if (aType.LowerCaseEqualsASCII(t)) { + type = t; + break; + } + } + NS_ENSURE_TRUE(type, NS_ERROR_INVALID_ARG); + + // We have only implemented username/password for SOCKS proxies. + if ((!aUsername.IsEmpty() || !aPassword.IsEmpty()) && + !aType.LowerCaseEqualsASCII(kProxyType_SOCKS) && + !aType.LowerCaseEqualsASCII(kProxyType_SOCKS4)) { + return NS_ERROR_NOT_IMPLEMENTED; + } + + return NewProxyInfo_Internal(type, aHost, aPort, aUsername, aPassword, + aProxyAuthorizationHeader, + aConnectionIsolationKey, aFlags, + aFailoverTimeout, aFailoverProxy, 0, aResult); +} + +NS_IMETHODIMP +nsProtocolProxyService::GetFailoverForProxy(nsIProxyInfo* aProxy, nsIURI* aURI, + nsresult aStatus, + nsIProxyInfo** aResult) { + // We only support failover when a PAC file is configured, either + // directly or via system settings + if (mProxyConfig != PROXYCONFIG_PAC && mProxyConfig != PROXYCONFIG_WPAD && + mProxyConfig != PROXYCONFIG_SYSTEM) + return NS_ERROR_NOT_AVAILABLE; + + // Verify that |aProxy| is one of our nsProxyInfo objects. + nsCOMPtr<nsProxyInfo> pi = do_QueryInterface(aProxy); + NS_ENSURE_ARG(pi); + // OK, the QI checked out. We can proceed. + + // Remember that this proxy is down. + DisableProxy(pi); + + // NOTE: At this point, we might want to prompt the user if we have + // not already tried going DIRECT. This is something that the + // classic codebase supported; however, IE6 does not prompt. + + if (!pi->mNext) return NS_ERROR_NOT_AVAILABLE; + + LOG(("PAC failover from %s %s:%d to %s %s:%d\n", pi->mType, pi->mHost.get(), + pi->mPort, pi->mNext->mType, pi->mNext->mHost.get(), pi->mNext->mPort)); + + *aResult = do_AddRef(pi->mNext).take(); + return NS_OK; +} + +namespace { // anon + +class ProxyFilterPositionComparator { + typedef RefPtr<nsProtocolProxyService::FilterLink> FilterLinkRef; + + public: + bool Equals(const FilterLinkRef& a, const FilterLinkRef& b) const { + return a->position == b->position; + } + bool LessThan(const FilterLinkRef& a, const FilterLinkRef& b) const { + return a->position < b->position; + } +}; + +class ProxyFilterObjectComparator { + typedef RefPtr<nsProtocolProxyService::FilterLink> FilterLinkRef; + + public: + bool Equals(const FilterLinkRef& link, const nsISupports* obj) const { + return obj == nsCOMPtr<nsISupports>(do_QueryInterface(link->filter)) || + obj == nsCOMPtr<nsISupports>(do_QueryInterface(link->channelFilter)); + } +}; + +} // namespace + +nsresult nsProtocolProxyService::InsertFilterLink(RefPtr<FilterLink>&& link) { + LOG(("nsProtocolProxyService::InsertFilterLink filter=%p", link.get())); + + if (mIsShutdown) { + return NS_ERROR_FAILURE; + } + + mFilters.AppendElement(link); + mFilters.Sort(ProxyFilterPositionComparator()); + return NS_OK; +} + +NS_IMETHODIMP +nsProtocolProxyService::RegisterFilter(nsIProtocolProxyFilter* filter, + uint32_t position) { + UnregisterFilter(filter); // remove this filter if we already have it + + RefPtr<FilterLink> link = new FilterLink(position, filter); + return InsertFilterLink(std::move(link)); +} + +NS_IMETHODIMP +nsProtocolProxyService::RegisterChannelFilter( + nsIProtocolProxyChannelFilter* channelFilter, uint32_t position) { + UnregisterChannelFilter( + channelFilter); // remove this filter if we already have it + + RefPtr<FilterLink> link = new FilterLink(position, channelFilter); + return InsertFilterLink(std::move(link)); +} + +nsresult nsProtocolProxyService::RemoveFilterLink(nsISupports* givenObject) { + LOG(("nsProtocolProxyService::RemoveFilterLink target=%p", givenObject)); + + return mFilters.RemoveElement(givenObject, ProxyFilterObjectComparator()) + ? NS_OK + : NS_ERROR_UNEXPECTED; +} + +NS_IMETHODIMP +nsProtocolProxyService::UnregisterFilter(nsIProtocolProxyFilter* filter) { + // QI to nsISupports so we can safely test object identity. + nsCOMPtr<nsISupports> givenObject = do_QueryInterface(filter); + return RemoveFilterLink(givenObject); +} + +NS_IMETHODIMP +nsProtocolProxyService::UnregisterChannelFilter( + nsIProtocolProxyChannelFilter* channelFilter) { + // QI to nsISupports so we can safely test object identity. + nsCOMPtr<nsISupports> givenObject = do_QueryInterface(channelFilter); + return RemoveFilterLink(givenObject); +} + +NS_IMETHODIMP +nsProtocolProxyService::GetProxyConfigType(uint32_t* aProxyConfigType) { + *aProxyConfigType = mProxyConfig; + return NS_OK; +} + +void nsProtocolProxyService::LoadHostFilters(const nsACString& aFilters) { + if (mIsShutdown) { + return; + } + + // check to see the owners flag? /!?/ TODO + if (mHostFiltersArray.Length() > 0) { + mHostFiltersArray.Clear(); + } + + // Reset mFilterLocalHosts - will be set to true if "<local>" is in pref + // string + mFilterLocalHosts = false; + + if (aFilters.IsEmpty()) { + return; + } + + // + // filter = ( host | domain | ipaddr ["/" mask] ) [":" port] + // filters = filter *( "," LWS filter) + // + mozilla::Tokenizer t(aFilters); + mozilla::Tokenizer::Token token; + bool eof = false; + // while (*filters) { + while (!eof) { + // skip over spaces and , + t.SkipWhites(); + while (t.CheckChar(',')) { + t.SkipWhites(); + } + + nsAutoCString portStr; + nsAutoCString hostStr; + nsAutoCString maskStr; + t.Record(); + + bool parsingIPv6 = false; + bool parsingPort = false; + bool parsingMask = false; + while (t.Next(token)) { + if (token.Equals(mozilla::Tokenizer::Token::EndOfFile())) { + eof = true; + break; + } + if (token.Equals(mozilla::Tokenizer::Token::Char(',')) || + token.Type() == mozilla::Tokenizer::TOKEN_WS) { + break; + } + + if (token.Equals(mozilla::Tokenizer::Token::Char('['))) { + parsingIPv6 = true; + continue; + } + + if (!parsingIPv6 && token.Equals(mozilla::Tokenizer::Token::Char(':'))) { + // Port is starting. Claim the previous as host. + if (parsingMask) { + t.Claim(maskStr); + } else { + t.Claim(hostStr); + } + t.Record(); + parsingPort = true; + continue; + } + + if (token.Equals(mozilla::Tokenizer::Token::Char('/'))) { + t.Claim(hostStr); + t.Record(); + parsingMask = true; + continue; + } + + if (token.Equals(mozilla::Tokenizer::Token::Char(']'))) { + parsingIPv6 = false; + continue; + } + } + if (!parsingPort && !parsingMask) { + t.Claim(hostStr); + } else if (parsingPort) { + t.Claim(portStr); + } else if (parsingMask) { + t.Claim(maskStr); + } else { + NS_WARNING("Could not parse this rule"); + continue; + } + + if (hostStr.IsEmpty()) { + continue; + } + + // If the current host filter is "<local>", then all local (i.e. + // no dots in the hostname) hosts should bypass the proxy + if (hostStr.EqualsIgnoreCase("<local>")) { + mFilterLocalHosts = true; + LOG( + ("loaded filter for local hosts " + "(plain host names, no dots)\n")); + // Continue to next host filter; + continue; + } + + // For all other host filters, create HostInfo object and add to list + HostInfo* hinfo = new HostInfo(); + nsresult rv = NS_OK; + + int32_t port = portStr.ToInteger(&rv); + if (NS_FAILED(rv)) { + port = 0; + } + hinfo->port = port; + + int32_t maskLen = maskStr.ToInteger(&rv); + if (NS_FAILED(rv)) { + maskLen = 128; + } + + // PR_StringToNetAddr can't parse brackets enclosed IPv6 + nsAutoCString addrString = hostStr; + if (hostStr.First() == '[' && hostStr.Last() == ']') { + addrString = Substring(hostStr, 1, hostStr.Length() - 2); + } + + PRNetAddr addr; + if (PR_StringToNetAddr(addrString.get(), &addr) == PR_SUCCESS) { + hinfo->is_ipaddr = true; + hinfo->ip.family = PR_AF_INET6; // we always store address as IPv6 + hinfo->ip.mask_len = maskLen; + + if (hinfo->ip.mask_len == 0) { + NS_WARNING("invalid mask"); + goto loser; + } + + if (addr.raw.family == PR_AF_INET) { + // convert to IPv4-mapped address + PR_ConvertIPv4AddrToIPv6(addr.inet.ip, &hinfo->ip.addr); + // adjust mask_len accordingly + if (hinfo->ip.mask_len <= 32) hinfo->ip.mask_len += 96; + } else if (addr.raw.family == PR_AF_INET6) { + // copy the address + memcpy(&hinfo->ip.addr, &addr.ipv6.ip, sizeof(PRIPv6Addr)); + } else { + NS_WARNING("unknown address family"); + goto loser; + } + + // apply mask to IPv6 address + proxy_MaskIPv6Addr(hinfo->ip.addr, hinfo->ip.mask_len); + } else { + nsAutoCString host; + if (hostStr.First() == '*') { + host = Substring(hostStr, 1); + } else { + host = hostStr; + } + + if (host.IsEmpty()) { + hinfo->name.host = nullptr; + goto loser; + } + + hinfo->name.host_len = host.Length(); + + hinfo->is_ipaddr = false; + hinfo->name.host = ToNewCString(host, mozilla::fallible); + + if (!hinfo->name.host) goto loser; + } + +//#define DEBUG_DUMP_FILTERS +#ifdef DEBUG_DUMP_FILTERS + printf("loaded filter[%zu]:\n", mHostFiltersArray.Length()); + printf(" is_ipaddr = %u\n", hinfo->is_ipaddr); + printf(" port = %u\n", hinfo->port); + printf(" host = %s\n", hostStr.get()); + if (hinfo->is_ipaddr) { + printf(" ip.family = %x\n", hinfo->ip.family); + printf(" ip.mask_len = %u\n", hinfo->ip.mask_len); + + PRNetAddr netAddr; + PR_SetNetAddr(PR_IpAddrNull, PR_AF_INET6, 0, &netAddr); + memcpy(&netAddr.ipv6.ip, &hinfo->ip.addr, sizeof(hinfo->ip.addr)); + + char buf[256]; + PR_NetAddrToString(&netAddr, buf, sizeof(buf)); + + printf(" ip.addr = %s\n", buf); + } else { + printf(" name.host = %s\n", hinfo->name.host); + } +#endif + + mHostFiltersArray.AppendElement(hinfo); + hinfo = nullptr; + loser: + delete hinfo; + } +} + +nsresult nsProtocolProxyService::GetProtocolInfo(nsIURI* uri, + nsProtocolInfo* info) { + MOZ_ASSERT(uri, "URI is null"); + MOZ_ASSERT(info, "info is null"); + + nsresult rv; + + rv = uri->GetScheme(info->scheme); + if (NS_FAILED(rv)) return rv; + + nsCOMPtr<nsIIOService> ios = do_GetIOService(&rv); + if (NS_FAILED(rv)) return rv; + + nsCOMPtr<nsIProtocolHandler> handler; + rv = ios->GetProtocolHandler(info->scheme.get(), getter_AddRefs(handler)); + if (NS_FAILED(rv)) return rv; + + rv = handler->DoGetProtocolFlags(uri, &info->flags); + if (NS_FAILED(rv)) return rv; + + rv = handler->GetDefaultPort(&info->defaultPort); + return rv; +} + +nsresult nsProtocolProxyService::NewProxyInfo_Internal( + const char* aType, const nsACString& aHost, int32_t aPort, + const nsACString& aUsername, const nsACString& aPassword, + const nsACString& aProxyAuthorizationHeader, + const nsACString& aConnectionIsolationKey, uint32_t aFlags, + uint32_t aFailoverTimeout, nsIProxyInfo* aFailoverProxy, + uint32_t aResolveFlags, nsIProxyInfo** aResult) { + if (aPort <= 0) aPort = -1; + + nsCOMPtr<nsProxyInfo> failover; + if (aFailoverProxy) { + failover = do_QueryInterface(aFailoverProxy); + NS_ENSURE_ARG(failover); + } + + RefPtr<nsProxyInfo> proxyInfo = new nsProxyInfo(); + + proxyInfo->mType = aType; + proxyInfo->mHost = aHost; + proxyInfo->mPort = aPort; + proxyInfo->mUsername = aUsername; + proxyInfo->mPassword = aPassword; + proxyInfo->mFlags = aFlags; + proxyInfo->mResolveFlags = aResolveFlags; + proxyInfo->mTimeout = + aFailoverTimeout == UINT32_MAX ? mFailedProxyTimeout : aFailoverTimeout; + proxyInfo->mProxyAuthorizationHeader = aProxyAuthorizationHeader; + proxyInfo->mConnectionIsolationKey = aConnectionIsolationKey; + failover.swap(proxyInfo->mNext); + + proxyInfo.forget(aResult); + return NS_OK; +} + +nsresult nsProtocolProxyService::Resolve_Internal(nsIChannel* channel, + const nsProtocolInfo& info, + uint32_t flags, + bool* usePACThread, + nsIProxyInfo** result) { + NS_ENSURE_ARG_POINTER(channel); + + *usePACThread = false; + *result = nullptr; + + if (!(info.flags & nsIProtocolHandler::ALLOWS_PROXY)) + return NS_OK; // Can't proxy this (filters may not override) + + nsCOMPtr<nsIURI> uri; + nsresult rv = GetProxyURI(channel, getter_AddRefs(uri)); + if (NS_FAILED(rv)) return rv; + + // See bug #586908. + // Avoid endless loop if |uri| is the current PAC-URI. Returning OK + // here means that we will not use a proxy for this connection. + if (mPACMan && mPACMan->IsPACURI(uri)) return NS_OK; + + // if proxies are enabled and this host:port combo is supposed to use a + // proxy, check for a proxy. + if ((mProxyConfig == PROXYCONFIG_DIRECT) || + !CanUseProxy(uri, info.defaultPort)) + return NS_OK; + + bool mainThreadOnly; + if (mSystemProxySettings && mProxyConfig == PROXYCONFIG_SYSTEM && + NS_SUCCEEDED(mSystemProxySettings->GetMainThreadOnly(&mainThreadOnly)) && + !mainThreadOnly) { + *usePACThread = true; + return NS_OK; + } + + if (mSystemProxySettings && mProxyConfig == PROXYCONFIG_SYSTEM) { + // If the system proxy setting implementation is not threadsafe (e.g + // linux gconf), we'll do it inline here. Such implementations promise + // not to block + // bug 1366133: this block uses GetPACURI & GetProxyForURI, which may + // hang on Windows platform. Fortunately, current implementation on + // Windows is not main thread only, so we are safe here. + + nsAutoCString PACURI; + nsAutoCString pacString; + + if (NS_SUCCEEDED(mSystemProxySettings->GetPACURI(PACURI)) && + !PACURI.IsEmpty()) { + // There is a PAC URI configured. If it is unchanged, then + // just execute the PAC thread. If it is changed then load + // the new value + + if (mPACMan && mPACMan->IsPACURI(PACURI)) { + // unchanged + *usePACThread = true; + return NS_OK; + } + + ConfigureFromPAC(PACURI, false); + return NS_OK; + } + + nsAutoCString spec; + nsAutoCString host; + nsAutoCString scheme; + int32_t port = -1; + + uri->GetAsciiSpec(spec); + uri->GetAsciiHost(host); + uri->GetScheme(scheme); + uri->GetPort(&port); + + if (flags & RESOLVE_PREFER_SOCKS_PROXY) { + LOG(("Ignoring RESOLVE_PREFER_SOCKS_PROXY for system proxy setting\n")); + } else if (flags & RESOLVE_PREFER_HTTPS_PROXY) { + scheme.AssignLiteral("https"); + } else if (flags & RESOLVE_IGNORE_URI_SCHEME) { + scheme.AssignLiteral("http"); + } + + // now try the system proxy settings for this particular url + if (NS_SUCCEEDED(mSystemProxySettings->GetProxyForURI(spec, scheme, host, + port, pacString))) { + nsCOMPtr<nsIProxyInfo> pi; + ProcessPACString(pacString, 0, getter_AddRefs(pi)); + + if (flags & RESOLVE_PREFER_SOCKS_PROXY && + flags & RESOLVE_PREFER_HTTPS_PROXY) { + nsAutoCString type; + pi->GetType(type); + // DIRECT from ProcessPACString 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 + // proxy precedence is SOCKS > HTTPS > DIRECT. + if (type.EqualsLiteral(kProxyType_DIRECT)) { + scheme.AssignLiteral(kProxyType_HTTPS); + if (NS_SUCCEEDED(mSystemProxySettings->GetProxyForURI( + spec, scheme, host, port, pacString))) { + ProcessPACString(pacString, 0, getter_AddRefs(pi)); + } + } + } + pi.forget(result); + return NS_OK; + } + } + + // if proxies are enabled and this host:port combo is supposed to use a + // proxy, check for a proxy. + if (mProxyConfig == PROXYCONFIG_DIRECT || + (mProxyConfig == PROXYCONFIG_MANUAL && + !CanUseProxy(uri, info.defaultPort))) + return NS_OK; + + // Proxy auto config magic... + if (mProxyConfig == PROXYCONFIG_PAC || mProxyConfig == PROXYCONFIG_WPAD) { + // Do not query PAC now. + *usePACThread = true; + return NS_OK; + } + + // If we aren't in manual proxy configuration mode then we don't + // want to honor any manual specific prefs that might be still set + if (mProxyConfig != PROXYCONFIG_MANUAL) return NS_OK; + + // proxy info values for manual configuration mode + const char* type = nullptr; + const nsACString* host = nullptr; + int32_t port = -1; + + uint32_t proxyFlags = 0; + + if ((flags & RESOLVE_PREFER_SOCKS_PROXY) && !mSOCKSProxyTarget.IsEmpty() && + (IsHostLocalTarget(mSOCKSProxyTarget) || mSOCKSProxyPort > 0)) { + host = &mSOCKSProxyTarget; + if (mSOCKSProxyVersion == 4) + type = kProxyType_SOCKS4; + else + type = kProxyType_SOCKS; + port = mSOCKSProxyPort; + if (mSOCKSProxyRemoteDNS) + proxyFlags |= nsIProxyInfo::TRANSPARENT_PROXY_RESOLVES_HOST; + } else if ((flags & RESOLVE_PREFER_HTTPS_PROXY) && + !mHTTPSProxyHost.IsEmpty() && mHTTPSProxyPort > 0) { + host = &mHTTPSProxyHost; + type = kProxyType_HTTP; + port = mHTTPSProxyPort; + } else if (!mHTTPProxyHost.IsEmpty() && mHTTPProxyPort > 0 && + ((flags & RESOLVE_IGNORE_URI_SCHEME) || + info.scheme.EqualsLiteral("http"))) { + host = &mHTTPProxyHost; + type = kProxyType_HTTP; + port = mHTTPProxyPort; + } else if (!mHTTPSProxyHost.IsEmpty() && mHTTPSProxyPort > 0 && + !(flags & RESOLVE_IGNORE_URI_SCHEME) && + info.scheme.EqualsLiteral("https")) { + host = &mHTTPSProxyHost; + type = kProxyType_HTTP; + port = mHTTPSProxyPort; + } else if (!mFTPProxyHost.IsEmpty() && mFTPProxyPort > 0 && + !(flags & RESOLVE_IGNORE_URI_SCHEME) && + info.scheme.EqualsLiteral("ftp")) { + host = &mFTPProxyHost; + type = kProxyType_HTTP; + port = mFTPProxyPort; + } else if (!mSOCKSProxyTarget.IsEmpty() && + (IsHostLocalTarget(mSOCKSProxyTarget) || mSOCKSProxyPort > 0)) { + host = &mSOCKSProxyTarget; + if (mSOCKSProxyVersion == 4) + type = kProxyType_SOCKS4; + else + type = kProxyType_SOCKS; + port = mSOCKSProxyPort; + if (mSOCKSProxyRemoteDNS) + proxyFlags |= nsIProxyInfo::TRANSPARENT_PROXY_RESOLVES_HOST; + } + + if (type) { + rv = NewProxyInfo_Internal(type, *host, port, ""_ns, ""_ns, ""_ns, ""_ns, + proxyFlags, UINT32_MAX, nullptr, flags, result); + if (NS_FAILED(rv)) return rv; + } + + return NS_OK; +} + +void nsProtocolProxyService::MaybeDisableDNSPrefetch(nsIProxyInfo* aProxy) { + // Disable Prefetch in the DNS service if a proxy is in use. + if (!aProxy) return; + + nsCOMPtr<nsProxyInfo> pi = do_QueryInterface(aProxy); + if (!pi || !pi->mType || pi->mType == kProxyType_DIRECT) return; + + nsCOMPtr<nsIDNSService> dns = do_GetService(NS_DNSSERVICE_CONTRACTID); + if (!dns) return; + nsCOMPtr<nsPIDNSService> pdns = do_QueryInterface(dns); + if (!pdns) return; + + // We lose the prefetch optimization for the life of the dns service. + pdns->SetPrefetchEnabled(false); +} + +void nsProtocolProxyService::CopyFilters(nsTArray<RefPtr<FilterLink>>& aCopy) { + MOZ_ASSERT(aCopy.Length() == 0); + aCopy.AppendElements(mFilters); +} + +bool nsProtocolProxyService::ApplyFilter( + FilterLink const* filterLink, nsIChannel* channel, + const nsProtocolInfo& info, nsCOMPtr<nsIProxyInfo> list, + nsIProxyProtocolFilterResult* callback) { + nsresult rv; + + // We prune the proxy list prior to invoking each filter. This may be + // somewhat inefficient, but it seems like a good idea since we want each + // filter to "see" a valid proxy list. + PruneProxyInfo(info, list); + + if (filterLink->filter) { + nsCOMPtr<nsIURI> uri; + Unused << GetProxyURI(channel, getter_AddRefs(uri)); + if (!uri) { + return false; + } + + rv = filterLink->filter->ApplyFilter(uri, list, callback); + return NS_SUCCEEDED(rv); + } + + if (filterLink->channelFilter) { + rv = filterLink->channelFilter->ApplyFilter(channel, list, callback); + return NS_SUCCEEDED(rv); + } + + return false; +} + +void nsProtocolProxyService::PruneProxyInfo(const nsProtocolInfo& info, + nsIProxyInfo** list) { + if (!*list) return; + + LOG(("nsProtocolProxyService::PruneProxyInfo ENTER list=%p", *list)); + + nsProxyInfo* head = nullptr; + CallQueryInterface(*list, &head); + if (!head) { + MOZ_ASSERT_UNREACHABLE("nsIProxyInfo must QI to nsProxyInfo"); + return; + } + NS_RELEASE(*list); + + // Pruning of disabled proxies works like this: + // - If all proxies are disabled, return the full list + // - Otherwise, remove the disabled proxies. + // + // Pruning of disallowed proxies works like this: + // - If the protocol handler disallows the proxy, then we disallow it. + + // Start by removing all disallowed proxies if required: + if (!(info.flags & nsIProtocolHandler::ALLOWS_PROXY_HTTP)) { + nsProxyInfo *last = nullptr, *iter = head; + while (iter) { + if ((iter->Type() == kProxyType_HTTP) || + (iter->Type() == kProxyType_HTTPS)) { + // reject! + if (last) + last->mNext = iter->mNext; + else + head = iter->mNext; + nsProxyInfo* next = iter->mNext; + iter->mNext = nullptr; + iter->Release(); + iter = next; + } else { + last = iter; + iter = iter->mNext; + } + } + if (!head) { + return; + } + } + + // Scan to see if all remaining non-direct proxies are disabled. If so, then + // we'll just bail and return them all. Otherwise, we'll go and prune the + // disabled ones. + + bool allNonDirectProxiesDisabled = true; + + nsProxyInfo* iter; + for (iter = head; iter; iter = iter->mNext) { + if (!IsProxyDisabled(iter) && iter->mType != kProxyType_DIRECT) { + allNonDirectProxiesDisabled = false; + break; + } + } + + if (allNonDirectProxiesDisabled) { + LOG(("All proxies are disabled, so trying all again")); + } else { + // remove any disabled proxies. + nsProxyInfo* last = nullptr; + for (iter = head; iter;) { + if (IsProxyDisabled(iter)) { + // reject! + nsProxyInfo* reject = iter; + + iter = iter->mNext; + if (last) + last->mNext = iter; + else + head = iter; + + reject->mNext = nullptr; + NS_RELEASE(reject); + continue; + } + + // since we are about to use this proxy, make sure it is not on + // the disabled proxy list. we'll add it back to that list if + // we have to (in GetFailoverForProxy). + // + // XXX(darin): It might be better to do this as a final pass. + // + EnableProxy(iter); + + last = iter; + iter = iter->mNext; + } + } + + // if only DIRECT was specified then return no proxy info, and we're done. + if (head && !head->mNext && head->mType == kProxyType_DIRECT) + NS_RELEASE(head); + + *list = head; // Transfer ownership + + LOG(("nsProtocolProxyService::PruneProxyInfo LEAVE list=%p", *list)); +} + +bool nsProtocolProxyService::GetIsPACLoading() { + return mPACMan && mPACMan->IsLoading(); +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/nsProtocolProxyService.h b/netwerk/base/nsProtocolProxyService.h new file mode 100644 index 0000000000..6b748e45b8 --- /dev/null +++ b/netwerk/base/nsProtocolProxyService.h @@ -0,0 +1,414 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef nsProtocolProxyService_h__ +#define nsProtocolProxyService_h__ + +#include "nsString.h" +#include "nsCOMPtr.h" +#include "nsTArray.h" +#include "nsIProtocolProxyService2.h" +#include "nsIProtocolProxyFilter.h" +#include "nsIProxyInfo.h" +#include "nsIObserver.h" +#include "nsDataHashtable.h" +#include "nsHashKeys.h" +#include "prio.h" +#include "mozilla/Attributes.h" + +class nsIPrefBranch; +class nsISystemProxySettings; + +namespace mozilla { +namespace net { + +typedef nsDataHashtable<nsCStringHashKey, uint32_t> nsFailedProxyTable; + +class nsPACMan; +class nsProxyInfo; +struct nsProtocolInfo; + +// CID for the nsProtocolProxyService class +// 091eedd8-8bae-4fe3-ad62-0c87351e640d +#define NS_PROTOCOL_PROXY_SERVICE_IMPL_CID \ + { \ + 0x091eedd8, 0x8bae, 0x4fe3, { \ + 0xad, 0x62, 0x0c, 0x87, 0x35, 0x1e, 0x64, 0x0d \ + } \ + } + +class nsProtocolProxyService final : public nsIProtocolProxyService2, + public nsIObserver { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIPROTOCOLPROXYSERVICE2 + NS_DECL_NSIPROTOCOLPROXYSERVICE + NS_DECL_NSIOBSERVER + + NS_DECLARE_STATIC_IID_ACCESSOR(NS_PROTOCOL_PROXY_SERVICE_IMPL_CID) + + nsProtocolProxyService(); + + nsresult Init(); + + public: + // An instance of this struct is allocated for each registered + // nsIProtocolProxyFilter and each nsIProtocolProxyChannelFilter. + class FilterLink { + public: + NS_INLINE_DECL_REFCOUNTING(FilterLink) + + uint32_t position; + nsCOMPtr<nsIProtocolProxyFilter> filter; + nsCOMPtr<nsIProtocolProxyChannelFilter> channelFilter; + + FilterLink(uint32_t p, nsIProtocolProxyFilter* f); + FilterLink(uint32_t p, nsIProtocolProxyChannelFilter* cf); + + private: + ~FilterLink(); + }; + + protected: + friend class nsAsyncResolveRequest; + friend class TestProtocolProxyService_LoadHostFilters_Test; // for gtest + + ~nsProtocolProxyService(); + + /** + * This method is called whenever a preference may have changed or + * to initialize all preferences. + * + * @param prefs + * This must be a pointer to the root pref branch. + * @param name + * This can be the name of a fully-qualified preference, or it can + * be null, in which case all preferences will be initialized. + */ + void PrefsChanged(nsIPrefBranch* prefs, const char* name); + + /** + * This method is called to create a nsProxyInfo instance from the given + * PAC-style proxy string. It parses up to the end of the string, or to + * the next ';' character. + * + * @param proxy + * The PAC-style proxy string to parse. This must not be null. + * @param aResolveFlags + * The flags passed to Resolve or AsyncResolve that are stored in + * proxyInfo. + * @param result + * Upon return this points to a newly allocated nsProxyInfo or null + * if the proxy string was invalid. + * + * @return A pointer beyond the parsed proxy string (never null). + */ + const char* ExtractProxyInfo(const char* proxy, uint32_t aResolveFlags, + nsProxyInfo** result); + + /** + * Load the specified PAC file. + * + * @param pacURI + * The URI spec of the PAC file to load. + */ + nsresult ConfigureFromPAC(const nsCString& pacURI, bool forceReload); + + /** + * This method builds a list of nsProxyInfo objects from the given PAC- + * style string. + * + * @param pacString + * The PAC-style proxy string to parse. This may be empty. + * @param aResolveFlags + * The flags passed to Resolve or AsyncResolve that are stored in + * proxyInfo. + * @param result + * The resulting list of proxy info objects. + */ + void ProcessPACString(const nsCString& pacString, uint32_t aResolveFlags, + nsIProxyInfo** result); + + /** + * This method generates a string valued identifier for the given + * nsProxyInfo object. + * + * @param pi + * The nsProxyInfo object from which to generate the key. + * @param result + * Upon return, this parameter holds the generated key. + */ + void GetProxyKey(nsProxyInfo* pi, nsCString& result); + + /** + * @return Seconds since start of session. + */ + uint32_t SecondsSinceSessionStart(); + + /** + * This method removes the specified proxy from the disabled list. + * + * @param pi + * The nsProxyInfo object identifying the proxy to enable. + */ + void EnableProxy(nsProxyInfo* pi); + + /** + * This method adds the specified proxy to the disabled list. + * + * @param pi + * The nsProxyInfo object identifying the proxy to disable. + */ + void DisableProxy(nsProxyInfo* pi); + + /** + * This method tests to see if the given proxy is disabled. + * + * @param pi + * The nsProxyInfo object identifying the proxy to test. + * + * @return True if the specified proxy is disabled. + */ + bool IsProxyDisabled(nsProxyInfo* pi); + + /** + * This method queries the protocol handler for the given scheme to check + * for the protocol flags and default port. + * + * @param uri + * The URI to query. + * @param info + * Holds information about the protocol upon return. Pass address + * of structure when you call this method. This parameter must not + * be null. + */ + nsresult GetProtocolInfo(nsIURI* uri, nsProtocolInfo* result); + + /** + * This method is an internal version nsIProtocolProxyService::newProxyInfo + * that expects a string literal for the type. + * + * @param type + * The proxy type. + * @param host + * The proxy host name (UTF-8 ok). + * @param port + * The proxy port number. + * @param username + * The username for the proxy (ASCII). May be "", but not null. + * @param password + * The password for the proxy (ASCII). May be "", but not null. + * @param flags + * The proxy flags (nsIProxyInfo::flags). + * @param timeout + * The failover timeout for this proxy. + * @param next + * The next proxy to try if this one fails. + * @param aResolveFlags + * The flags passed to resolve (from nsIProtocolProxyService). + * @param result + * The resulting nsIProxyInfo object. + */ + nsresult NewProxyInfo_Internal(const char* type, const nsACString& host, + int32_t port, const nsACString& username, + const nsACString& password, + const nsACString& aProxyAuthorizationHeader, + const nsACString& aConnectionIsolationKey, + uint32_t flags, uint32_t timeout, + nsIProxyInfo* next, uint32_t aResolveFlags, + nsIProxyInfo** result); + + /** + * This method is an internal version of Resolve that does not query PAC. + * It performs all of the built-in processing, and reports back to the + * caller with either the proxy info result or a flag to instruct the + * caller to use PAC instead. + * + * @param channel + * The channel to test. + * @param info + * Information about the URI's protocol. + * @param flags + * The flags passed to either the resolve or the asyncResolve method. + * @param usePAC + * If this flag is set upon return, then PAC should be queried to + * resolve the proxy info. + * @param result + * The resulting proxy info or null. + */ + nsresult Resolve_Internal(nsIChannel* channel, const nsProtocolInfo& info, + uint32_t flags, bool* usePAC, + nsIProxyInfo** result); + + /** + * Shallow copy of the current list of registered filters so that + * we can safely let them asynchronously process a single proxy + * resolution request. + */ + void CopyFilters(nsTArray<RefPtr<FilterLink>>& aCopy); + + /** + * This method applies the provided filter to the given proxy info + * list, and expects |callback| be called on (synchronously or + * asynchronously) to provide the updated proxyinfo list. + */ + bool ApplyFilter(FilterLink const* filterLink, nsIChannel* channel, + const nsProtocolInfo& info, nsCOMPtr<nsIProxyInfo> proxyInfo, + nsIProxyProtocolFilterResult* callback); + + /** + * This method prunes out disabled and disallowed proxies from a given + * proxy info list. + * + * @param info + * Information about the URI's protocol. + * @param proxyInfo + * The proxy info list to be modified. This is an inout param. + */ + void PruneProxyInfo(const nsProtocolInfo& info, nsIProxyInfo** proxyInfo); + + /** + * This method is a simple wrapper around PruneProxyInfo that takes the + * proxy info list inout param as a nsCOMPtr. + */ + void PruneProxyInfo(const nsProtocolInfo& info, + nsCOMPtr<nsIProxyInfo>& proxyInfo) { + nsIProxyInfo* pi = nullptr; + proxyInfo.swap(pi); + PruneProxyInfo(info, &pi); + proxyInfo.swap(pi); + } + + /** + * This method populates mHostFiltersArray from the given string. + * + * @param hostFilters + * A "no-proxy-for" exclusion list. + */ + void LoadHostFilters(const nsACString& hostFilters); + + /** + * This method checks the given URI against mHostFiltersArray. + * + * @param uri + * The URI to test. + * @param defaultPort + * The default port for the given URI. + * + * @return True if the URI can use the specified proxy. + */ + bool CanUseProxy(nsIURI* uri, int32_t defaultPort); + + /** + * Disable Prefetch in the DNS service if a proxy is in use. + * + * @param aProxy + * The proxy information + */ + void MaybeDisableDNSPrefetch(nsIProxyInfo* aProxy); + + private: + nsresult SetupPACThread( + nsISerialEventTarget* mainThreadEventTarget = nullptr); + nsresult ResetPACThread(); + nsresult ReloadNetworkPAC(); + + nsresult AsyncConfigureFromPAC(bool aForceReload, bool aResetPACThread); + nsresult OnAsyncGetPACURI(bool aForceReload, bool aResetPACThread, + nsresult aResult, const nsACString& aUri); + + public: + // The Sun Forte compiler and others implement older versions of the + // C++ standard's rules on access and nested classes. These structs + // need to be public in order to deal with those compilers. + + struct HostInfoIP { + uint16_t family; + uint16_t mask_len; + PRIPv6Addr addr; // possibly IPv4-mapped address + }; + + struct HostInfoName { + char* host; + uint32_t host_len; + }; + + protected: + // simplified array of filters defined by this struct + struct HostInfo { + bool is_ipaddr; + int32_t port; + union { + HostInfoIP ip; + HostInfoName name; + }; + + HostInfo() + : is_ipaddr(false), + port(0) { /* other members intentionally uninitialized */ + } + ~HostInfo() { + if (!is_ipaddr && name.host) free(name.host); + } + }; + + private: + // Private methods to insert and remove FilterLinks from the FilterLink chain. + nsresult InsertFilterLink(RefPtr<FilterLink>&& link); + nsresult RemoveFilterLink(nsISupports* givenObject); + + protected: + // Indicates if local hosts (plain hostnames, no dots) should use the proxy + bool mFilterLocalHosts; + + // Holds an array of HostInfo objects + nsTArray<UniquePtr<HostInfo>> mHostFiltersArray; + + // Filters, always sorted by the position. + nsTArray<RefPtr<FilterLink>> mFilters; + + uint32_t mProxyConfig; + + nsCString mHTTPProxyHost; + int32_t mHTTPProxyPort; + + nsCString mFTPProxyHost; + int32_t mFTPProxyPort; + + nsCString mHTTPSProxyHost; + int32_t mHTTPSProxyPort; + + // mSOCKSProxyTarget could be a host, a domain socket path, + // or a named-pipe name. + nsCString mSOCKSProxyTarget; + int32_t mSOCKSProxyPort; + int32_t mSOCKSProxyVersion; + bool mSOCKSProxyRemoteDNS; + bool mProxyOverTLS; + bool mWPADOverDHCPEnabled; + + RefPtr<nsPACMan> mPACMan; // non-null if we are using PAC + nsCOMPtr<nsISystemProxySettings> mSystemProxySettings; + + PRTime mSessionStart; + nsFailedProxyTable mFailedProxies; + int32_t mFailedProxyTimeout; + + private: + nsresult AsyncResolveInternal(nsIChannel* channel, uint32_t flags, + nsIProtocolProxyCallback* callback, + nsICancelable** result, bool isSyncOK, + nsISerialEventTarget* mainThreadEventTarget); + bool mIsShutdown; + nsCOMPtr<nsISerialEventTarget> mProxySettingTarget; +}; + +NS_DEFINE_STATIC_IID_ACCESSOR(nsProtocolProxyService, + NS_PROTOCOL_PROXY_SERVICE_IMPL_CID) + +} // namespace net +} // namespace mozilla + +#endif // !nsProtocolProxyService_h__ diff --git a/netwerk/base/nsProxyInfo.cpp b/netwerk/base/nsProxyInfo.cpp new file mode 100644 index 0000000000..8a72a91c42 --- /dev/null +++ b/netwerk/base/nsProxyInfo.cpp @@ -0,0 +1,196 @@ +/* -*- 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 "nsProxyInfo.h" + +#include "mozilla/net/NeckoChannelParams.h" +#include "nsCOMPtr.h" + +namespace mozilla { +namespace net { + +// Yes, we support QI to nsProxyInfo +NS_IMPL_ISUPPORTS(nsProxyInfo, nsProxyInfo, nsIProxyInfo) + +// These pointers are declared in nsProtocolProxyService.cpp and +// comparison of mType by string pointer is valid within necko +extern const char kProxyType_HTTP[]; +extern const char kProxyType_HTTPS[]; +extern const char kProxyType_SOCKS[]; +extern const char kProxyType_SOCKS4[]; +extern const char kProxyType_SOCKS5[]; +extern const char kProxyType_DIRECT[]; + +nsProxyInfo::nsProxyInfo(const nsACString& aType, const nsACString& aHost, + int32_t aPort, const nsACString& aUsername, + const nsACString& aPassword, uint32_t aFlags, + uint32_t aTimeout, uint32_t aResolveFlags, + const nsACString& aProxyAuthorizationHeader, + const nsACString& aConnectionIsolationKey) + : mHost(aHost), + mUsername(aUsername), + mPassword(aPassword), + mProxyAuthorizationHeader(aProxyAuthorizationHeader), + mConnectionIsolationKey(aConnectionIsolationKey), + mPort(aPort), + mFlags(aFlags), + mResolveFlags(aResolveFlags), + mTimeout(aTimeout), + mNext(nullptr) { + if (aType.EqualsASCII(kProxyType_HTTP)) { + mType = kProxyType_HTTP; + } else if (aType.EqualsASCII(kProxyType_HTTPS)) { + mType = kProxyType_HTTPS; + } else if (aType.EqualsASCII(kProxyType_SOCKS)) { + mType = kProxyType_SOCKS; + } else if (aType.EqualsASCII(kProxyType_SOCKS4)) { + mType = kProxyType_SOCKS4; + } else if (aType.EqualsASCII(kProxyType_SOCKS5)) { + mType = kProxyType_SOCKS5; + } else if (aType.EqualsASCII(kProxyType_PROXY)) { + mType = kProxyType_PROXY; + } else { + mType = kProxyType_DIRECT; + } +} + +NS_IMETHODIMP +nsProxyInfo::GetHost(nsACString& result) { + result = mHost; + return NS_OK; +} + +NS_IMETHODIMP +nsProxyInfo::GetPort(int32_t* result) { + *result = mPort; + return NS_OK; +} + +NS_IMETHODIMP +nsProxyInfo::GetType(nsACString& result) { + result = mType; + return NS_OK; +} + +NS_IMETHODIMP +nsProxyInfo::GetFlags(uint32_t* result) { + *result = mFlags; + return NS_OK; +} + +NS_IMETHODIMP +nsProxyInfo::GetResolveFlags(uint32_t* result) { + *result = mResolveFlags; + return NS_OK; +} + +NS_IMETHODIMP +nsProxyInfo::SetResolveFlags(uint32_t flags) { + mResolveFlags = flags; + return NS_OK; +} + +NS_IMETHODIMP +nsProxyInfo::GetUsername(nsACString& result) { + result = mUsername; + return NS_OK; +} + +NS_IMETHODIMP +nsProxyInfo::GetPassword(nsACString& result) { + result = mPassword; + return NS_OK; +} + +NS_IMETHODIMP +nsProxyInfo::GetProxyAuthorizationHeader(nsACString& result) { + result = mProxyAuthorizationHeader; + return NS_OK; +} + +NS_IMETHODIMP +nsProxyInfo::GetConnectionIsolationKey(nsACString& result) { + result = mConnectionIsolationKey; + return NS_OK; +} + +NS_IMETHODIMP +nsProxyInfo::GetFailoverTimeout(uint32_t* result) { + *result = mTimeout; + return NS_OK; +} + +NS_IMETHODIMP +nsProxyInfo::GetFailoverProxy(nsIProxyInfo** result) { + NS_IF_ADDREF(*result = mNext); + return NS_OK; +} + +NS_IMETHODIMP +nsProxyInfo::SetFailoverProxy(nsIProxyInfo* proxy) { + nsCOMPtr<nsProxyInfo> pi = do_QueryInterface(proxy); + NS_ENSURE_ARG(pi); + + pi.swap(mNext); + return NS_OK; +} + +bool nsProxyInfo::IsDirect() { + if (!mType) return true; + return mType == kProxyType_DIRECT; +} + +bool nsProxyInfo::IsHTTP() { return mType == kProxyType_HTTP; } + +bool nsProxyInfo::IsHTTPS() { return mType == kProxyType_HTTPS; } + +bool nsProxyInfo::IsSOCKS() { + return mType == kProxyType_SOCKS || mType == kProxyType_SOCKS4 || + mType == kProxyType_SOCKS5; +} + +/* static */ +void nsProxyInfo::SerializeProxyInfo(nsProxyInfo* aProxyInfo, + nsTArray<ProxyInfoCloneArgs>& aResult) { + for (nsProxyInfo* iter = aProxyInfo; iter; iter = iter->mNext) { + ProxyInfoCloneArgs* arg = aResult.AppendElement(); + arg->type() = nsCString(iter->Type()); + arg->host() = iter->Host(); + arg->port() = iter->Port(); + arg->username() = iter->Username(); + arg->password() = iter->Password(); + arg->proxyAuthorizationHeader() = iter->ProxyAuthorizationHeader(); + arg->connectionIsolationKey() = iter->ConnectionIsolationKey(); + arg->flags() = iter->Flags(); + arg->timeout() = iter->Timeout(); + arg->resolveFlags() = iter->ResolveFlags(); + } +} + +/* static */ +nsProxyInfo* nsProxyInfo::DeserializeProxyInfo( + const nsTArray<ProxyInfoCloneArgs>& aArgs) { + nsProxyInfo *pi = nullptr, *first = nullptr, *last = nullptr; + for (const ProxyInfoCloneArgs& info : aArgs) { + pi = new nsProxyInfo(info.type(), info.host(), info.port(), info.username(), + info.password(), info.flags(), info.timeout(), + info.resolveFlags(), info.proxyAuthorizationHeader(), + info.connectionIsolationKey()); + if (last) { + last->mNext = pi; + // |mNext| will be released in |last|'s destructor. + NS_IF_ADDREF(last->mNext); + } else { + first = pi; + } + last = pi; + } + + return first; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/nsProxyInfo.h b/netwerk/base/nsProxyInfo.h new file mode 100644 index 0000000000..798f615707 --- /dev/null +++ b/netwerk/base/nsProxyInfo.h @@ -0,0 +1,102 @@ +/* -*- 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/. */ + +#ifndef nsProxyInfo_h__ +#define nsProxyInfo_h__ + +#include "nsIProxyInfo.h" +#include "nsString.h" +#include "mozilla/Atomics.h" +#include "mozilla/Attributes.h" + +// Use to support QI nsIProxyInfo to nsProxyInfo +#define NS_PROXYINFO_IID \ + { /* ed42f751-825e-4cc2-abeb-3670711a8b85 */ \ + 0xed42f751, 0x825e, 0x4cc2, { \ + 0xab, 0xeb, 0x36, 0x70, 0x71, 0x1a, 0x8b, 0x85 \ + } \ + } + +namespace mozilla { +namespace net { + +class ProxyInfoCloneArgs; + +// This class is exposed to other classes inside Necko for fast access +// to the nsIProxyInfo attributes. +class nsProxyInfo final : public nsIProxyInfo { + public: + NS_DECLARE_STATIC_IID_ACCESSOR(NS_PROXYINFO_IID) + + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIPROXYINFO + + // Cheap accessors for use within Necko + const nsCString& Host() const { return mHost; } + int32_t Port() const { return mPort; } + const char* Type() const { return mType; } + uint32_t Flags() const { return mFlags; } + const nsCString& Username() const { return mUsername; } + const nsCString& Password() const { return mPassword; } + uint32_t Timeout() { return mTimeout; } + uint32_t ResolveFlags() { return mResolveFlags; } + const nsCString& ProxyAuthorizationHeader() const { + return mProxyAuthorizationHeader; + } + const nsCString& ConnectionIsolationKey() const { + return mConnectionIsolationKey; + } + + bool IsDirect(); + bool IsHTTP(); + bool IsHTTPS(); + bool IsSOCKS(); + + static void SerializeProxyInfo(nsProxyInfo* aProxyInfo, + nsTArray<ProxyInfoCloneArgs>& aResult); + static nsProxyInfo* DeserializeProxyInfo( + const nsTArray<ProxyInfoCloneArgs>& aArgs); + + private: + friend class nsProtocolProxyService; + + explicit nsProxyInfo(const char* type = nullptr) + : mType(type), + mPort(-1), + mFlags(0), + mResolveFlags(0), + mTimeout(UINT32_MAX), + mNext(nullptr) {} + + nsProxyInfo(const nsACString& aType, const nsACString& aHost, int32_t aPort, + const nsACString& aUsername, const nsACString& aPassword, + uint32_t aFlags, uint32_t aTimeout, uint32_t aResolveFlags, + const nsACString& aProxyAuthorizationHeader, + const nsACString& aConnectionIsolationKey); + + ~nsProxyInfo() { NS_IF_RELEASE(mNext); } + + const char* mType; // pointer to statically allocated value + nsCString mHost; + nsCString mUsername; + nsCString mPassword; + nsCString mProxyAuthorizationHeader; + nsCString mConnectionIsolationKey; + int32_t mPort; + uint32_t mFlags; + // We need to read on multiple threads, but don't need to sync on anything + // else + Atomic<uint32_t, Relaxed> mResolveFlags; + uint32_t mTimeout; + nsProxyInfo* mNext; +}; + +NS_DEFINE_STATIC_IID_ACCESSOR(nsProxyInfo, NS_PROXYINFO_IID) + +} // namespace net +} // namespace mozilla + +#endif // nsProxyInfo_h__ diff --git a/netwerk/base/nsReadLine.h b/netwerk/base/nsReadLine.h new file mode 100644 index 0000000000..f1e4693f92 --- /dev/null +++ b/netwerk/base/nsReadLine.h @@ -0,0 +1,131 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * 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/. */ + +#ifndef nsReadLine_h__ +#define nsReadLine_h__ + +#include "nsIInputStream.h" +#include "mozilla/Likely.h" + +/** + * @file + * Functions to read complete lines from an input stream. + * + * To properly use the helper function in here (NS_ReadLine) the caller should + * create a nsLineBuffer<T> with new, and pass it to NS_ReadLine every time it + * wants a line out. + * + * When done, the object should be deleted. + */ + +/** + * @internal + * Buffer size. This many bytes will be buffered. If a line is longer than this, + * the partial line will be appended to the out parameter of NS_ReadLine and the + * buffer will be emptied. + * Note: if you change this constant, please update the regression test in + * netwerk/test/unit/test_readline.js accordingly (bug 397850). + */ +#define kLineBufferSize 4096 + +/** + * @internal + * Line buffer structure, buffers data from an input stream. + * The buffer is empty when |start| == |end|. + * Invariant: |start| <= |end| + */ +template <typename CharT> +class nsLineBuffer { + public: + nsLineBuffer() : start(buf), end(buf) {} + + CharT buf[kLineBufferSize + 1]; + CharT* start; + CharT* end; +}; + +/** + * Read a line from an input stream. Lines are separated by '\r' (0x0D) or '\n' + * (0x0A), or "\r\n" or "\n\r". + * + * @param aStream + * The stream to read from + * @param aBuffer + * The line buffer to use. A single line buffer must not be used with + * different input streams. + * @param aLine [out] + * The string where the line will be stored. + * @param more [out] + * Whether more data is available in the buffer. If true, NS_ReadLine may + * be called again to read further lines. Otherwise, further calls to + * NS_ReadLine will return an error. + * + * @retval NS_OK + * Read successful + * @retval error + * Input stream returned an error upon read. See + * nsIInputStream::read. + */ +template <typename CharT, class StreamType, class StringType> +nsresult NS_ReadLine(StreamType* aStream, nsLineBuffer<CharT>* aBuffer, + StringType& aLine, bool* more) { + CharT eolchar = 0; // the first eol char or 1 after \r\n or \n\r is found + + aLine.Truncate(); + + while (true) { // will be returning out of this loop on eol or eof + if (aBuffer->start == aBuffer->end) { // buffer is empty. Read into it. + uint32_t bytesRead; + nsresult rv = aStream->Read(aBuffer->buf, kLineBufferSize, &bytesRead); + if (NS_FAILED(rv) || MOZ_UNLIKELY(bytesRead == 0)) { + *more = false; + return rv; + } + aBuffer->start = aBuffer->buf; + aBuffer->end = aBuffer->buf + bytesRead; + *(aBuffer->end) = '\0'; + } + + /* + * Walk the buffer looking for an end-of-line. + * There are 3 cases to consider: + * 1. the eol char is the last char in the buffer + * 2. the eol char + one more char at the end of the buffer + * 3. the eol char + two or more chars at the end of the buffer + * we need at least one char after the first eol char to determine if + * it's a \r\n or \n\r sequence (and skip over it), and we need one + * more char after the end-of-line to set |more| correctly. + */ + CharT* current = aBuffer->start; + if (MOZ_LIKELY(eolchar == 0)) { + for (; current < aBuffer->end; ++current) { + if (*current == '\n' || *current == '\r') { + eolchar = *current; + *current++ = '\0'; + aLine.Append(aBuffer->start); + break; + } + } + } + if (MOZ_LIKELY(eolchar != 0)) { + for (; current < aBuffer->end; ++current) { + if ((eolchar == '\r' && *current == '\n') || + (eolchar == '\n' && *current == '\r')) { + eolchar = 1; + continue; + } + aBuffer->start = current; + *more = true; + return NS_OK; + } + } + + if (eolchar == 0) aLine.Append(aBuffer->start); + aBuffer->start = aBuffer->end; // mark the buffer empty + } +} + +#endif // nsReadLine_h__ diff --git a/netwerk/base/nsRedirectHistoryEntry.cpp b/netwerk/base/nsRedirectHistoryEntry.cpp new file mode 100644 index 0000000000..527bb1597f --- /dev/null +++ b/netwerk/base/nsRedirectHistoryEntry.cpp @@ -0,0 +1,43 @@ +/* -*- 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 "nsRedirectHistoryEntry.h" +#include "nsCOMPtr.h" +#include "nsIURI.h" +#include "nsIPrincipal.h" + +namespace mozilla { +namespace net { + +NS_IMPL_ISUPPORTS(nsRedirectHistoryEntry, nsIRedirectHistoryEntry) + +nsRedirectHistoryEntry::nsRedirectHistoryEntry(nsIPrincipal* aPrincipal, + nsIURI* aReferrer, + const nsACString& aRemoteAddress) + : mPrincipal(aPrincipal), + mReferrer(aReferrer), + mRemoteAddress(aRemoteAddress) {} + +NS_IMETHODIMP +nsRedirectHistoryEntry::GetRemoteAddress(nsACString& result) { + result = mRemoteAddress; + return NS_OK; +} + +NS_IMETHODIMP +nsRedirectHistoryEntry::GetReferrerURI(nsIURI** referrer) { + NS_IF_ADDREF(*referrer = mReferrer); + return NS_OK; +} + +NS_IMETHODIMP +nsRedirectHistoryEntry::GetPrincipal(nsIPrincipal** principal) { + NS_IF_ADDREF(*principal = mPrincipal); + return NS_OK; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/nsRedirectHistoryEntry.h b/netwerk/base/nsRedirectHistoryEntry.h new file mode 100644 index 0000000000..d0b79d5094 --- /dev/null +++ b/netwerk/base/nsRedirectHistoryEntry.h @@ -0,0 +1,35 @@ +/* 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/. */ + +#ifndef nsRedirectHistoryEntry_h__ +#define nsRedirectHistoryEntry_h__ + +#include "nsIRedirectHistoryEntry.h" + +class nsIURI; +class nsIPrincipal; + +namespace mozilla { +namespace net { + +class nsRedirectHistoryEntry final : public nsIRedirectHistoryEntry { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIREDIRECTHISTORYENTRY + + nsRedirectHistoryEntry(nsIPrincipal* aPrincipal, nsIURI* aReferrer, + const nsACString& aRemoteAddress); + + private: + ~nsRedirectHistoryEntry() = default; + + nsCOMPtr<nsIPrincipal> mPrincipal; + nsCOMPtr<nsIURI> mReferrer; + nsCString mRemoteAddress; +}; + +} // namespace net +} // namespace mozilla + +#endif // nsRedirectHistoryEntry_h__ diff --git a/netwerk/base/nsRequestObserverProxy.cpp b/netwerk/base/nsRequestObserverProxy.cpp new file mode 100644 index 0000000000..2f2e688a69 --- /dev/null +++ b/netwerk/base/nsRequestObserverProxy.cpp @@ -0,0 +1,175 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "mozilla/DebugOnly.h" + +#include "nscore.h" +#include "nsRequestObserverProxy.h" +#include "nsIRequest.h" +#include "mozilla/Logging.h" +#include "mozilla/IntegerPrintfMacros.h" + +namespace mozilla { +namespace net { + +static LazyLogModule gRequestObserverProxyLog("nsRequestObserverProxy"); + +#undef LOG +#define LOG(args) MOZ_LOG(gRequestObserverProxyLog, LogLevel::Debug, args) + +//----------------------------------------------------------------------------- +// nsARequestObserverEvent internal class... +//----------------------------------------------------------------------------- + +nsARequestObserverEvent::nsARequestObserverEvent(nsIRequest* request) + : Runnable("net::nsARequestObserverEvent"), mRequest(request) { + MOZ_ASSERT(mRequest, "null pointer"); +} + +//----------------------------------------------------------------------------- +// nsOnStartRequestEvent internal class... +//----------------------------------------------------------------------------- + +class nsOnStartRequestEvent : public nsARequestObserverEvent { + RefPtr<nsRequestObserverProxy> mProxy; + + public: + nsOnStartRequestEvent(nsRequestObserverProxy* proxy, nsIRequest* request) + : nsARequestObserverEvent(request), mProxy(proxy) { + MOZ_ASSERT(mProxy, "null pointer"); + } + + NS_IMETHOD Run() override { + LOG(("nsOnStartRequestEvent::HandleEvent [req=%p]\n", mRequest.get())); + + if (!mProxy->mObserver) { + MOZ_ASSERT_UNREACHABLE( + "already handled onStopRequest event " + "(observer is null)"); + return NS_OK; + } + + LOG(("handle startevent=%p\n", this)); + nsresult rv = mProxy->mObserver->OnStartRequest(mRequest); + if (NS_FAILED(rv)) { + LOG(("OnStartRequest failed [rv=%" PRIx32 "] canceling request!\n", + static_cast<uint32_t>(rv))); + rv = mRequest->Cancel(rv); + NS_ASSERTION(NS_SUCCEEDED(rv), "Cancel failed for request!"); + } + + return NS_OK; + } + + private: + virtual ~nsOnStartRequestEvent() = default; +}; + +//----------------------------------------------------------------------------- +// nsOnStopRequestEvent internal class... +//----------------------------------------------------------------------------- + +class nsOnStopRequestEvent : public nsARequestObserverEvent { + RefPtr<nsRequestObserverProxy> mProxy; + + public: + nsOnStopRequestEvent(nsRequestObserverProxy* proxy, nsIRequest* request) + : nsARequestObserverEvent(request), mProxy(proxy) { + MOZ_ASSERT(mProxy, "null pointer"); + } + + NS_IMETHOD Run() override { + LOG(("nsOnStopRequestEvent::HandleEvent [req=%p]\n", mRequest.get())); + + nsMainThreadPtrHandle<nsIRequestObserver> observer = mProxy->mObserver; + if (!observer) { + MOZ_ASSERT_UNREACHABLE( + "already handled onStopRequest event " + "(observer is null)"); + return NS_OK; + } + // Do not allow any more events to be handled after OnStopRequest + mProxy->mObserver = nullptr; + + nsresult status = NS_OK; + DebugOnly<nsresult> rv = mRequest->GetStatus(&status); + NS_ASSERTION(NS_SUCCEEDED(rv), "GetStatus failed for request!"); + + LOG(("handle stopevent=%p\n", this)); + (void)observer->OnStopRequest(mRequest, status); + + return NS_OK; + } + + private: + virtual ~nsOnStopRequestEvent() = default; +}; + +//----------------------------------------------------------------------------- +// nsRequestObserverProxy::nsISupports implementation... +//----------------------------------------------------------------------------- + +NS_IMPL_ISUPPORTS(nsRequestObserverProxy, nsIRequestObserver, + nsIRequestObserverProxy) + +//----------------------------------------------------------------------------- +// nsRequestObserverProxy::nsIRequestObserver implementation... +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +nsRequestObserverProxy::OnStartRequest(nsIRequest* request) { + LOG(("nsRequestObserverProxy::OnStartRequest [this=%p req=%p]\n", this, + request)); + + RefPtr<nsOnStartRequestEvent> ev = new nsOnStartRequestEvent(this, request); + + LOG(("post startevent=%p\n", ev.get())); + return FireEvent(ev); +} + +NS_IMETHODIMP +nsRequestObserverProxy::OnStopRequest(nsIRequest* request, nsresult status) { + LOG(("nsRequestObserverProxy: OnStopRequest [this=%p req=%p status=%" PRIx32 + "]\n", + this, request, static_cast<uint32_t>(status))); + + // The status argument is ignored because, by the time the OnStopRequestEvent + // is actually processed, the status of the request may have changed :-( + // To make sure that an accurate status code is always used, GetStatus() is + // called when the OnStopRequestEvent is actually processed (see above). + + RefPtr<nsOnStopRequestEvent> ev = new nsOnStopRequestEvent(this, request); + + LOG(("post stopevent=%p\n", ev.get())); + return FireEvent(ev); +} + +//----------------------------------------------------------------------------- +// nsRequestObserverProxy::nsIRequestObserverProxy implementation... +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +nsRequestObserverProxy::Init(nsIRequestObserver* observer, + nsISupports* context) { + NS_ENSURE_ARG_POINTER(observer); + mObserver = new nsMainThreadPtrHolder<nsIRequestObserver>( + "nsRequestObserverProxy::mObserver", observer); + mContext = new nsMainThreadPtrHolder<nsISupports>( + "nsRequestObserverProxy::mContext", context); + + return NS_OK; +} + +//----------------------------------------------------------------------------- +// nsRequestObserverProxy implementation... +//----------------------------------------------------------------------------- + +nsresult nsRequestObserverProxy::FireEvent(nsARequestObserverEvent* event) { + nsCOMPtr<nsIEventTarget> mainThread(GetMainThreadEventTarget()); + return mainThread->Dispatch(event, NS_DISPATCH_NORMAL); +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/nsRequestObserverProxy.h b/netwerk/base/nsRequestObserverProxy.h new file mode 100644 index 0000000000..e1ccec0c4c --- /dev/null +++ b/netwerk/base/nsRequestObserverProxy.h @@ -0,0 +1,56 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef nsRequestObserverProxy_h__ +#define nsRequestObserverProxy_h__ + +#include "nsIRequestObserver.h" +#include "nsIRequestObserverProxy.h" +#include "nsIRequest.h" +#include "nsThreadUtils.h" +#include "nsCOMPtr.h" +#include "nsProxyRelease.h" + +namespace mozilla { +namespace net { + +class nsARequestObserverEvent; + +class nsRequestObserverProxy final : public nsIRequestObserverProxy { + ~nsRequestObserverProxy() = default; + + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIREQUESTOBSERVER + NS_DECL_NSIREQUESTOBSERVERPROXY + + nsRequestObserverProxy() = default; + + nsIRequestObserver* Observer() { return mObserver; } + + nsresult FireEvent(nsARequestObserverEvent*); + + protected: + nsMainThreadPtrHandle<nsIRequestObserver> mObserver; + nsMainThreadPtrHandle<nsISupports> mContext; + + friend class nsOnStartRequestEvent; + friend class nsOnStopRequestEvent; +}; + +class nsARequestObserverEvent : public Runnable { + public: + explicit nsARequestObserverEvent(nsIRequest*); + + protected: + virtual ~nsARequestObserverEvent() = default; + + nsCOMPtr<nsIRequest> mRequest; +}; + +} // namespace net +} // namespace mozilla + +#endif // nsRequestObserverProxy_h__ diff --git a/netwerk/base/nsSerializationHelper.cpp b/netwerk/base/nsSerializationHelper.cpp new file mode 100644 index 0000000000..6e2efb7c57 --- /dev/null +++ b/netwerk/base/nsSerializationHelper.cpp @@ -0,0 +1,54 @@ +/* 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 "nsSerializationHelper.h" + +#include "mozilla/Base64.h" +#include "nsISerializable.h" +#include "nsIObjectOutputStream.h" +#include "nsIObjectInputStream.h" +#include "nsString.h" +#include "nsBase64Encoder.h" +#include "nsComponentManagerUtils.h" +#include "nsStringStream.h" + +using namespace mozilla; + +nsresult NS_SerializeToString(nsISerializable* obj, nsACString& str) { + RefPtr<nsBase64Encoder> stream(new nsBase64Encoder()); + if (!stream) return NS_ERROR_OUT_OF_MEMORY; + + nsCOMPtr<nsIObjectOutputStream> objstream = NS_NewObjectOutputStream(stream); + nsresult rv = + objstream->WriteCompoundObject(obj, NS_GET_IID(nsISupports), true); + NS_ENSURE_SUCCESS(rv, rv); + return stream->Finish(str); +} + +nsresult NS_DeserializeObject(const nsACString& str, nsISupports** obj) { + nsCString decodedData; + nsresult rv = Base64Decode(str, decodedData); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIInputStream> stream; + rv = NS_NewCStringInputStream(getter_AddRefs(stream), std::move(decodedData)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIObjectInputStream> objstream = NS_NewObjectInputStream(stream); + return objstream->ReadObject(true, obj); +} + +NS_IMPL_ISUPPORTS(nsSerializationHelper, nsISerializationHelper) + +NS_IMETHODIMP +nsSerializationHelper::SerializeToString(nsISerializable* serializable, + nsACString& _retval) { + return NS_SerializeToString(serializable, _retval); +} + +NS_IMETHODIMP +nsSerializationHelper::DeserializeObject(const nsACString& input, + nsISupports** _retval) { + return NS_DeserializeObject(input, _retval); +} diff --git a/netwerk/base/nsSerializationHelper.h b/netwerk/base/nsSerializationHelper.h new file mode 100644 index 0000000000..4e21a4c2df --- /dev/null +++ b/netwerk/base/nsSerializationHelper.h @@ -0,0 +1,35 @@ +/* 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/. */ + +/** @file + * Helper functions for (de)serializing objects to/from ASCII strings. + */ + +#ifndef NSSERIALIZATIONHELPER_H_ +#define NSSERIALIZATIONHELPER_H_ + +#include "nsStringFwd.h" +#include "nsISerializationHelper.h" +#include "mozilla/Attributes.h" + +class nsISerializable; + +/** + * Serialize an object to an ASCII string. + */ +nsresult NS_SerializeToString(nsISerializable* obj, nsACString& str); + +/** + * Deserialize an object. + */ +nsresult NS_DeserializeObject(const nsACString& str, nsISupports** obj); + +class nsSerializationHelper final : public nsISerializationHelper { + ~nsSerializationHelper() = default; + + NS_DECL_ISUPPORTS + NS_DECL_NSISERIALIZATIONHELPER +}; + +#endif diff --git a/netwerk/base/nsServerSocket.cpp b/netwerk/base/nsServerSocket.cpp new file mode 100644 index 0000000000..e0ac43ebd9 --- /dev/null +++ b/netwerk/base/nsServerSocket.cpp @@ -0,0 +1,550 @@ +/* vim:set ts=2 sw=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 "nsSocketTransport2.h" +#include "nsServerSocket.h" +#include "nsProxyRelease.h" +#include "nsError.h" +#include "nsNetCID.h" +#include "prnetdb.h" +#include "prio.h" +#include "nsThreadUtils.h" +#include "mozilla/Attributes.h" +#include "mozilla/EndianUtils.h" +#include "mozilla/net/DNS.h" +#include "nsServiceManagerUtils.h" +#include "nsIFile.h" + +namespace mozilla { +namespace net { + +//----------------------------------------------------------------------------- + +typedef void (nsServerSocket::*nsServerSocketFunc)(void); + +static nsresult PostEvent(nsServerSocket* s, nsServerSocketFunc func) { + nsCOMPtr<nsIRunnable> ev = NewRunnableMethod("net::PostEvent", s, func); + if (!gSocketTransportService) return NS_ERROR_FAILURE; + + return gSocketTransportService->Dispatch(ev, NS_DISPATCH_NORMAL); +} + +//----------------------------------------------------------------------------- +// nsServerSocket +//----------------------------------------------------------------------------- + +nsServerSocket::nsServerSocket() + : mFD(nullptr), + mLock("nsServerSocket.mLock"), + mAttached(false), + mKeepWhenOffline(false) { + this->mAddr.raw.family = 0; + this->mAddr.inet.family = 0; + this->mAddr.inet.port = 0; + this->mAddr.inet.ip = 0; + this->mAddr.ipv6.family = 0; + this->mAddr.ipv6.port = 0; + this->mAddr.ipv6.flowinfo = 0; + this->mAddr.ipv6.scope_id = 0; + this->mAddr.local.family = 0; + // we want to be able to access the STS directly, and it may not have been + // constructed yet. the STS constructor sets gSocketTransportService. + if (!gSocketTransportService) { + // This call can fail if we're offline, for example. + nsCOMPtr<nsISocketTransportService> sts = + do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID); + } + // make sure the STS sticks around as long as we do + NS_IF_ADDREF(gSocketTransportService); +} + +nsServerSocket::~nsServerSocket() { + Close(); // just in case :) + + // release our reference to the STS + nsSocketTransportService* serv = gSocketTransportService; + NS_IF_RELEASE(serv); +} + +void nsServerSocket::OnMsgClose() { + SOCKET_LOG(("nsServerSocket::OnMsgClose [this=%p]\n", this)); + + if (NS_FAILED(mCondition)) return; + + // tear down socket. this signals the STS to detach our socket handler. + mCondition = NS_BINDING_ABORTED; + + // if we are attached, then we'll close the socket in our OnSocketDetached. + // otherwise, call OnSocketDetached from here. + if (!mAttached) OnSocketDetached(mFD); +} + +void nsServerSocket::OnMsgAttach() { + SOCKET_LOG(("nsServerSocket::OnMsgAttach [this=%p]\n", this)); + + if (NS_FAILED(mCondition)) return; + + mCondition = TryAttach(); + + // if we hit an error while trying to attach then bail... + if (NS_FAILED(mCondition)) { + NS_ASSERTION(!mAttached, "should not be attached already"); + OnSocketDetached(mFD); + } +} + +nsresult nsServerSocket::TryAttach() { + nsresult rv; + + if (!gSocketTransportService) return NS_ERROR_FAILURE; + + // + // find out if it is going to be ok to attach another socket to the STS. + // if not then we have to wait for the STS to tell us that it is ok. + // the notification is asynchronous, which means that when we could be + // in a race to call AttachSocket once notified. for this reason, when + // we get notified, we just re-enter this function. as a result, we are + // sure to ask again before calling AttachSocket. in this way we deal + // with the race condition. though it isn't the most elegant solution, + // it is far simpler than trying to build a system that would guarantee + // FIFO ordering (which wouldn't even be that valuable IMO). see bug + // 194402 for more info. + // + if (!gSocketTransportService->CanAttachSocket()) { + nsCOMPtr<nsIRunnable> event = NewRunnableMethod( + "net::nsServerSocket::OnMsgAttach", this, &nsServerSocket::OnMsgAttach); + if (!event) return NS_ERROR_OUT_OF_MEMORY; + + nsresult rv = gSocketTransportService->NotifyWhenCanAttachSocket(event); + if (NS_FAILED(rv)) return rv; + } + + // + // ok, we can now attach our socket to the STS for polling + // + rv = gSocketTransportService->AttachSocket(mFD, this); + if (NS_FAILED(rv)) return rv; + + mAttached = true; + + // + // now, configure our poll flags for listening... + // + mPollFlags = (PR_POLL_READ | PR_POLL_EXCEPT); + return NS_OK; +} + +void nsServerSocket::CreateClientTransport(PRFileDesc* aClientFD, + const NetAddr& aClientAddr) { + RefPtr<nsSocketTransport> trans = new nsSocketTransport; + if (NS_WARN_IF(!trans)) { + mCondition = NS_ERROR_OUT_OF_MEMORY; + return; + } + + nsresult rv = trans->InitWithConnectedSocket(aClientFD, &aClientAddr); + if (NS_WARN_IF(NS_FAILED(rv))) { + mCondition = rv; + return; + } + + mListener->OnSocketAccepted(this, trans); +} + +//----------------------------------------------------------------------------- +// nsServerSocket::nsASocketHandler +//----------------------------------------------------------------------------- + +void nsServerSocket::OnSocketReady(PRFileDesc* fd, int16_t outFlags) { + NS_ASSERTION(NS_SUCCEEDED(mCondition), "oops"); + NS_ASSERTION(mFD == fd, "wrong file descriptor"); + NS_ASSERTION(outFlags != -1, "unexpected timeout condition reached"); + + if (outFlags & (PR_POLL_ERR | PR_POLL_HUP | PR_POLL_NVAL)) { + NS_WARNING("error polling on listening socket"); + mCondition = NS_ERROR_UNEXPECTED; + return; + } + + PRFileDesc* clientFD; + PRNetAddr prClientAddr; + + // NSPR doesn't tell us the peer address's length (as provided by the + // 'accept' system call), so we can't distinguish between named, + // unnamed, and abstract peer addresses. Clear prClientAddr first, so + // that the path will at least be reliably empty for unnamed and + // abstract addresses, and not garbage when the peer is unnamed. + memset(&prClientAddr, 0, sizeof(prClientAddr)); + + clientFD = PR_Accept(mFD, &prClientAddr, PR_INTERVAL_NO_WAIT); + if (!clientFD) { + NS_WARNING("PR_Accept failed"); + mCondition = NS_ERROR_UNEXPECTED; + return; + } + PR_SetFDInheritable(clientFD, false); + + NetAddr clientAddr(&prClientAddr); + // Accept succeeded, create socket transport and notify consumer + CreateClientTransport(clientFD, clientAddr); +} + +void nsServerSocket::OnSocketDetached(PRFileDesc* fd) { + // force a failure condition if none set; maybe the STS is shutting down :-/ + if (NS_SUCCEEDED(mCondition)) mCondition = NS_ERROR_ABORT; + + if (mFD) { + NS_ASSERTION(mFD == fd, "wrong file descriptor"); + PR_Close(mFD); + mFD = nullptr; + } + + if (mListener) { + mListener->OnStopListening(this, mCondition); + + // need to atomically clear mListener. see our Close() method. + RefPtr<nsIServerSocketListener> listener = nullptr; + { + MutexAutoLock lock(mLock); + listener = ToRefPtr(std::move(mListener)); + } + + // XXX we need to proxy the release to the listener's target thread to work + // around bug 337492. + if (listener) { + NS_ProxyRelease("nsServerSocket::mListener", mListenerTarget, + listener.forget()); + } + } +} + +void nsServerSocket::IsLocal(bool* aIsLocal) { +#if defined(XP_UNIX) + // Unix-domain sockets are always local. + if (mAddr.raw.family == PR_AF_LOCAL) { + *aIsLocal = true; + return; + } +#endif + + // If bound to loopback, this server socket only accepts local connections. + *aIsLocal = PR_IsNetAddrType(&mAddr, PR_IpAddrLoopback); +} + +void nsServerSocket::KeepWhenOffline(bool* aKeepWhenOffline) { + *aKeepWhenOffline = mKeepWhenOffline; +} + +//----------------------------------------------------------------------------- +// nsServerSocket::nsISupports +//----------------------------------------------------------------------------- + +NS_IMPL_ISUPPORTS(nsServerSocket, nsIServerSocket) + +//----------------------------------------------------------------------------- +// nsServerSocket::nsIServerSocket +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +nsServerSocket::Init(int32_t aPort, bool aLoopbackOnly, int32_t aBackLog) { + return InitSpecialConnection(aPort, aLoopbackOnly ? LoopbackOnly : 0, + aBackLog); +} + +NS_IMETHODIMP +nsServerSocket::InitIPv6(int32_t aPort, bool aLoopbackOnly, int32_t aBackLog) { + PRNetAddrValue val; + PRNetAddr addr; + + if (aPort < 0) { + aPort = 0; + } + if (aLoopbackOnly) { + val = PR_IpAddrLoopback; + } else { + val = PR_IpAddrAny; + } + PR_SetNetAddr(val, PR_AF_INET6, aPort, &addr); + + mKeepWhenOffline = false; + return InitWithAddress(&addr, aBackLog); +} + +NS_IMETHODIMP +nsServerSocket::InitWithFilename(nsIFile* aPath, uint32_t aPermissions, + int32_t aBacklog) { +#if defined(XP_UNIX) + nsresult rv; + + nsAutoCString path; + rv = aPath->GetNativePath(path); + if (NS_FAILED(rv)) return rv; + + // Create a Unix domain PRNetAddr referring to the given path. + PRNetAddr addr; + if (path.Length() > sizeof(addr.local.path) - 1) + return NS_ERROR_FILE_NAME_TOO_LONG; + addr.local.family = PR_AF_LOCAL; + memcpy(addr.local.path, path.get(), path.Length()); + addr.local.path[path.Length()] = '\0'; + + rv = InitWithAddress(&addr, aBacklog); + if (NS_FAILED(rv)) return rv; + + return aPath->SetPermissions(aPermissions); +#else + return NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED; +#endif +} + +NS_IMETHODIMP +nsServerSocket::InitWithAbstractAddress(const nsACString& aName, + int32_t aBacklog) { + // Abstract socket address is supported on Linux and Android only. + // If not Linux, we should return error. +#if defined(XP_LINUX) + // Create an abstract socket address PRNetAddr referring to the name + PRNetAddr addr; + if (aName.Length() > sizeof(addr.local.path) - 2) { + return NS_ERROR_FILE_NAME_TOO_LONG; + } + addr.local.family = PR_AF_LOCAL; + addr.local.path[0] = 0; + memcpy(addr.local.path + 1, aName.BeginReading(), aName.Length()); + addr.local.path[aName.Length() + 1] = 0; + + return InitWithAddress(&addr, aBacklog); +#else + return NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED; +#endif +} + +NS_IMETHODIMP +nsServerSocket::InitSpecialConnection(int32_t aPort, nsServerSocketFlag aFlags, + int32_t aBackLog) { + PRNetAddrValue val; + PRNetAddr addr; + + if (aPort < 0) aPort = 0; + if (aFlags & nsIServerSocket::LoopbackOnly) + val = PR_IpAddrLoopback; + else + val = PR_IpAddrAny; + PR_SetNetAddr(val, PR_AF_INET, aPort, &addr); + + mKeepWhenOffline = ((aFlags & nsIServerSocket::KeepWhenOffline) != 0); + return InitWithAddress(&addr, aBackLog); +} + +NS_IMETHODIMP +nsServerSocket::InitWithAddress(const PRNetAddr* aAddr, int32_t aBackLog) { + NS_ENSURE_TRUE(mFD == nullptr, NS_ERROR_ALREADY_INITIALIZED); + nsresult rv; + + // + // configure listening socket... + // + + mFD = PR_OpenTCPSocket(aAddr->raw.family); + if (!mFD) { + NS_WARNING("unable to create server socket"); + return ErrorAccordingToNSPR(PR_GetError()); + } + + PR_SetFDInheritable(mFD, false); + + PRSocketOptionData opt; + + opt.option = PR_SockOpt_Reuseaddr; + opt.value.reuse_addr = true; + PR_SetSocketOption(mFD, &opt); + + opt.option = PR_SockOpt_Nonblocking; + opt.value.non_blocking = true; + PR_SetSocketOption(mFD, &opt); + + if (PR_Bind(mFD, aAddr) != PR_SUCCESS) { + NS_WARNING("failed to bind socket"); + goto fail; + } + + if (aBackLog < 0) aBackLog = 5; // seems like a reasonable default + + if (PR_Listen(mFD, aBackLog) != PR_SUCCESS) { + NS_WARNING("cannot listen on socket"); + goto fail; + } + + // get the resulting socket address, which may be different than what + // we passed to bind. + if (PR_GetSockName(mFD, &mAddr) != PR_SUCCESS) { + NS_WARNING("cannot get socket name"); + goto fail; + } + + // Set any additional socket defaults needed by child classes + rv = SetSocketDefaults(); + if (NS_WARN_IF(NS_FAILED(rv))) { + goto fail; + } + + // wait until AsyncListen is called before polling the socket for + // client connections. + return NS_OK; + +fail: + rv = ErrorAccordingToNSPR(PR_GetError()); + Close(); + return rv; +} + +NS_IMETHODIMP +nsServerSocket::Close() { + { + MutexAutoLock lock(mLock); + // we want to proxy the close operation to the socket thread if a listener + // has been set. otherwise, we should just close the socket here... + if (!mListener) { + if (mFD) { + PR_Close(mFD); + mFD = nullptr; + } + return NS_OK; + } + } + return PostEvent(this, &nsServerSocket::OnMsgClose); +} + +namespace { + +class ServerSocketListenerProxy final : public nsIServerSocketListener { + ~ServerSocketListenerProxy() = default; + + public: + explicit ServerSocketListenerProxy(nsIServerSocketListener* aListener) + : mListener(new nsMainThreadPtrHolder<nsIServerSocketListener>( + "ServerSocketListenerProxy::mListener", aListener)), + mTarget(GetCurrentEventTarget()) {} + + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSISERVERSOCKETLISTENER + + class OnSocketAcceptedRunnable : public Runnable { + public: + OnSocketAcceptedRunnable( + const nsMainThreadPtrHandle<nsIServerSocketListener>& aListener, + nsIServerSocket* aServ, nsISocketTransport* aTransport) + : Runnable("net::ServerSocketListenerProxy::OnSocketAcceptedRunnable"), + mListener(aListener), + mServ(aServ), + mTransport(aTransport) {} + + NS_DECL_NSIRUNNABLE + + private: + nsMainThreadPtrHandle<nsIServerSocketListener> mListener; + nsCOMPtr<nsIServerSocket> mServ; + nsCOMPtr<nsISocketTransport> mTransport; + }; + + class OnStopListeningRunnable : public Runnable { + public: + OnStopListeningRunnable( + const nsMainThreadPtrHandle<nsIServerSocketListener>& aListener, + nsIServerSocket* aServ, nsresult aStatus) + : Runnable("net::ServerSocketListenerProxy::OnStopListeningRunnable"), + mListener(aListener), + mServ(aServ), + mStatus(aStatus) {} + + NS_DECL_NSIRUNNABLE + + private: + nsMainThreadPtrHandle<nsIServerSocketListener> mListener; + nsCOMPtr<nsIServerSocket> mServ; + nsresult mStatus; + }; + + private: + nsMainThreadPtrHandle<nsIServerSocketListener> mListener; + nsCOMPtr<nsIEventTarget> mTarget; +}; + +NS_IMPL_ISUPPORTS(ServerSocketListenerProxy, nsIServerSocketListener) + +NS_IMETHODIMP +ServerSocketListenerProxy::OnSocketAccepted(nsIServerSocket* aServ, + nsISocketTransport* aTransport) { + RefPtr<OnSocketAcceptedRunnable> r = + new OnSocketAcceptedRunnable(mListener, aServ, aTransport); + return mTarget->Dispatch(r, NS_DISPATCH_NORMAL); +} + +NS_IMETHODIMP +ServerSocketListenerProxy::OnStopListening(nsIServerSocket* aServ, + nsresult aStatus) { + RefPtr<OnStopListeningRunnable> r = + new OnStopListeningRunnable(mListener, aServ, aStatus); + return mTarget->Dispatch(r, NS_DISPATCH_NORMAL); +} + +NS_IMETHODIMP +ServerSocketListenerProxy::OnSocketAcceptedRunnable::Run() { + mListener->OnSocketAccepted(mServ, mTransport); + return NS_OK; +} + +NS_IMETHODIMP +ServerSocketListenerProxy::OnStopListeningRunnable::Run() { + mListener->OnStopListening(mServ, mStatus); + return NS_OK; +} + +} // namespace + +NS_IMETHODIMP +nsServerSocket::AsyncListen(nsIServerSocketListener* aListener) { + // ensuring mFD implies ensuring mLock + NS_ENSURE_TRUE(mFD, NS_ERROR_NOT_INITIALIZED); + NS_ENSURE_TRUE(mListener == nullptr, NS_ERROR_IN_PROGRESS); + { + MutexAutoLock lock(mLock); + mListener = new ServerSocketListenerProxy(aListener); + mListenerTarget = GetCurrentEventTarget(); + } + + // Child classes may need to do additional setup just before listening begins + nsresult rv = OnSocketListen(); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + return PostEvent(this, &nsServerSocket::OnMsgAttach); +} + +NS_IMETHODIMP +nsServerSocket::GetPort(int32_t* aResult) { + // no need to enter the lock here + uint16_t port; + if (mAddr.raw.family == PR_AF_INET) + port = mAddr.inet.port; + else if (mAddr.raw.family == PR_AF_INET6) + port = mAddr.ipv6.port; + else + return NS_ERROR_FAILURE; + + *aResult = static_cast<int32_t>(NetworkEndian::readUint16(&port)); + return NS_OK; +} + +NS_IMETHODIMP +nsServerSocket::GetAddress(PRNetAddr* aResult) { + // no need to enter the lock here + memcpy(aResult, &mAddr, sizeof(mAddr)); + return NS_OK; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/nsServerSocket.h b/netwerk/base/nsServerSocket.h new file mode 100644 index 0000000000..3690a99a9d --- /dev/null +++ b/netwerk/base/nsServerSocket.h @@ -0,0 +1,66 @@ +/* vim:set ts=2 sw=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/. */ + +#ifndef nsServerSocket_h__ +#define nsServerSocket_h__ + +#include "prio.h" +#include "nsASocketHandler.h" +#include "nsIServerSocket.h" +#include "mozilla/Mutex.h" + +//----------------------------------------------------------------------------- + +class nsIEventTarget; +namespace mozilla { +namespace net { +union NetAddr; + +class nsServerSocket : public nsASocketHandler, public nsIServerSocket { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSISERVERSOCKET + + // nsASocketHandler methods: + virtual void OnSocketReady(PRFileDesc* fd, int16_t outFlags) override; + virtual void OnSocketDetached(PRFileDesc* fd) override; + virtual void IsLocal(bool* aIsLocal) override; + virtual void KeepWhenOffline(bool* aKeepWhenOffline) override; + + virtual uint64_t ByteCountSent() override { return 0; } + virtual uint64_t ByteCountReceived() override { return 0; } + nsServerSocket(); + + virtual void CreateClientTransport(PRFileDesc* clientFD, + const mozilla::net::NetAddr& clientAddr); + virtual nsresult SetSocketDefaults() { return NS_OK; } + virtual nsresult OnSocketListen() { return NS_OK; } + + protected: + virtual ~nsServerSocket(); + PRFileDesc* mFD; + nsCOMPtr<nsIServerSocketListener> mListener; + + private: + void OnMsgClose(); + void OnMsgAttach(); + + // try attaching our socket (mFD) to the STS's poll list. + nsresult TryAttach(); + + // lock protects access to mListener; so it is not cleared while being used. + mozilla::Mutex mLock; + PRNetAddr mAddr; + nsCOMPtr<nsIEventTarget> mListenerTarget; + bool mAttached; + bool mKeepWhenOffline; +}; + +} // namespace net +} // namespace mozilla + +//----------------------------------------------------------------------------- + +#endif // nsServerSocket_h__ diff --git a/netwerk/base/nsSimpleNestedURI.cpp b/netwerk/base/nsSimpleNestedURI.cpp new file mode 100644 index 0000000000..6427009c84 --- /dev/null +++ b/netwerk/base/nsSimpleNestedURI.cpp @@ -0,0 +1,227 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "base/basictypes.h" + +#include "nsNetCID.h" +#include "nsNetUtil.h" +#include "nsSimpleNestedURI.h" +#include "nsIObjectInputStream.h" +#include "nsIObjectOutputStream.h" + +#include "mozilla/ipc/URIUtils.h" + +namespace mozilla { +namespace net { + +NS_IMPL_CLASSINFO(nsSimpleNestedURI, nullptr, nsIClassInfo::THREADSAFE, + NS_SIMPLENESTEDURI_CID) +// Empty CI getter. We only need nsIClassInfo for Serialization +NS_IMPL_CI_INTERFACE_GETTER0(nsSimpleNestedURI) + +NS_IMPL_ADDREF_INHERITED(nsSimpleNestedURI, nsSimpleURI) +NS_IMPL_RELEASE_INHERITED(nsSimpleNestedURI, nsSimpleURI) +NS_IMPL_QUERY_INTERFACE_CI_INHERITED(nsSimpleNestedURI, nsSimpleURI, + nsINestedURI) + +nsSimpleNestedURI::nsSimpleNestedURI(nsIURI* innerURI) : mInnerURI(innerURI) { + NS_ASSERTION(innerURI, "Must have inner URI"); +} + +nsresult nsSimpleNestedURI::SetPathQueryRef(const nsACString& aPathQueryRef) { + NS_ENSURE_TRUE(mInnerURI, NS_ERROR_NOT_INITIALIZED); + + nsCOMPtr<nsIURI> inner; + nsresult rv = + NS_MutateURI(mInnerURI).SetPathQueryRef(aPathQueryRef).Finalize(inner); + NS_ENSURE_SUCCESS(rv, rv); + rv = nsSimpleURI::SetPathQueryRef(aPathQueryRef); + NS_ENSURE_SUCCESS(rv, rv); + // If the regular SetPathQueryRef worked, also set it on the inner URI + mInnerURI = inner; + return NS_OK; +} + +nsresult nsSimpleNestedURI::SetQuery(const nsACString& aQuery) { + NS_ENSURE_TRUE(mInnerURI, NS_ERROR_NOT_INITIALIZED); + + nsCOMPtr<nsIURI> inner; + nsresult rv = NS_MutateURI(mInnerURI).SetQuery(aQuery).Finalize(inner); + NS_ENSURE_SUCCESS(rv, rv); + rv = nsSimpleURI::SetQuery(aQuery); + NS_ENSURE_SUCCESS(rv, rv); + // If the regular SetQuery worked, also set it on the inner URI + mInnerURI = inner; + return NS_OK; +} + +nsresult nsSimpleNestedURI::SetRef(const nsACString& aRef) { + NS_ENSURE_TRUE(mInnerURI, NS_ERROR_NOT_INITIALIZED); + + nsCOMPtr<nsIURI> inner; + nsresult rv = NS_MutateURI(mInnerURI).SetRef(aRef).Finalize(inner); + NS_ENSURE_SUCCESS(rv, rv); + rv = nsSimpleURI::SetRef(aRef); + NS_ENSURE_SUCCESS(rv, rv); + // If the regular SetRef worked, also set it on the inner URI + mInnerURI = inner; + return NS_OK; +} + +// nsISerializable + +NS_IMETHODIMP +nsSimpleNestedURI::Read(nsIObjectInputStream* aStream) { + MOZ_ASSERT_UNREACHABLE("Use nsIURIMutator.read() instead"); + return NS_ERROR_NOT_IMPLEMENTED; +} + +nsresult nsSimpleNestedURI::ReadPrivate(nsIObjectInputStream* aStream) { + nsresult rv = nsSimpleURI::ReadPrivate(aStream); + if (NS_FAILED(rv)) return rv; + + nsCOMPtr<nsISupports> supports; + rv = aStream->ReadObject(true, getter_AddRefs(supports)); + if (NS_FAILED(rv)) return rv; + + mInnerURI = do_QueryInterface(supports, &rv); + if (NS_FAILED(rv)) return rv; + + return rv; +} + +NS_IMETHODIMP +nsSimpleNestedURI::Write(nsIObjectOutputStream* aStream) { + nsCOMPtr<nsISerializable> serializable = do_QueryInterface(mInnerURI); + if (!serializable) { + // We can't serialize ourselves + return NS_ERROR_NOT_AVAILABLE; + } + + nsresult rv = nsSimpleURI::Write(aStream); + if (NS_FAILED(rv)) return rv; + + rv = aStream->WriteCompoundObject(mInnerURI, NS_GET_IID(nsIURI), true); + return rv; +} + +NS_IMETHODIMP_(void) +nsSimpleNestedURI::Serialize(mozilla::ipc::URIParams& aParams) { + using namespace mozilla::ipc; + + SimpleNestedURIParams params; + URIParams simpleParams; + + nsSimpleURI::Serialize(simpleParams); + params.simpleParams() = simpleParams; + + SerializeURI(mInnerURI, params.innerURI()); + + aParams = params; +} + +bool nsSimpleNestedURI::Deserialize(const mozilla::ipc::URIParams& aParams) { + using namespace mozilla::ipc; + + if (aParams.type() != URIParams::TSimpleNestedURIParams) { + NS_ERROR("Received unknown parameters from the other process!"); + return false; + } + + const SimpleNestedURIParams& params = aParams.get_SimpleNestedURIParams(); + if (!nsSimpleURI::Deserialize(params.simpleParams())) return false; + + mInnerURI = DeserializeURI(params.innerURI()); + return true; +} + +// nsINestedURI + +NS_IMETHODIMP +nsSimpleNestedURI::GetInnerURI(nsIURI** aURI) { + NS_ENSURE_TRUE(mInnerURI, NS_ERROR_NOT_INITIALIZED); + + nsCOMPtr<nsIURI> uri = mInnerURI; + uri.forget(aURI); + return NS_OK; +} + +NS_IMETHODIMP +nsSimpleNestedURI::GetInnermostURI(nsIURI** uri) { + return NS_ImplGetInnermostURI(this, uri); +} + +// nsSimpleURI overrides +/* virtual */ +nsresult nsSimpleNestedURI::EqualsInternal( + nsIURI* other, nsSimpleURI::RefHandlingEnum refHandlingMode, bool* result) { + *result = false; + NS_ENSURE_TRUE(mInnerURI, NS_ERROR_NOT_INITIALIZED); + + if (other) { + bool correctScheme; + nsresult rv = other->SchemeIs(mScheme.get(), &correctScheme); + NS_ENSURE_SUCCESS(rv, rv); + + if (correctScheme) { + nsCOMPtr<nsINestedURI> nest = do_QueryInterface(other); + if (nest) { + nsCOMPtr<nsIURI> otherInner; + rv = nest->GetInnerURI(getter_AddRefs(otherInner)); + NS_ENSURE_SUCCESS(rv, rv); + + return (refHandlingMode == eHonorRef) + ? otherInner->Equals(mInnerURI, result) + : otherInner->EqualsExceptRef(mInnerURI, result); + } + } + } + + return NS_OK; +} + +/* virtual */ +nsSimpleURI* nsSimpleNestedURI::StartClone( + nsSimpleURI::RefHandlingEnum refHandlingMode, const nsACString& newRef) { + NS_ENSURE_TRUE(mInnerURI, nullptr); + + nsCOMPtr<nsIURI> innerClone; + nsresult rv = NS_OK; + if (refHandlingMode == eHonorRef) { + innerClone = mInnerURI; + } else if (refHandlingMode == eReplaceRef) { + rv = NS_GetURIWithNewRef(mInnerURI, newRef, getter_AddRefs(innerClone)); + } else { + rv = NS_GetURIWithoutRef(mInnerURI, getter_AddRefs(innerClone)); + } + + if (NS_FAILED(rv)) { + return nullptr; + } + + nsSimpleNestedURI* url = new nsSimpleNestedURI(innerClone); + SetRefOnClone(url, refHandlingMode, newRef); + + return url; +} + +// Queries this list of interfaces. If none match, it queries mURI. +NS_IMPL_NSIURIMUTATOR_ISUPPORTS(nsSimpleNestedURI::Mutator, nsIURISetters, + nsIURIMutator, nsISerializable, + nsINestedURIMutator) + +NS_IMETHODIMP +nsSimpleNestedURI::Mutate(nsIURIMutator** aMutator) { + RefPtr<nsSimpleNestedURI::Mutator> mutator = new nsSimpleNestedURI::Mutator(); + nsresult rv = mutator->InitFromURI(this); + if (NS_FAILED(rv)) { + return rv; + } + mutator.forget(aMutator); + return NS_OK; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/nsSimpleNestedURI.h b/netwerk/base/nsSimpleNestedURI.h new file mode 100644 index 0000000000..0887431421 --- /dev/null +++ b/netwerk/base/nsSimpleNestedURI.h @@ -0,0 +1,112 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +/** + * URI class to be used for cases when a simple URI actually resolves to some + * other sort of URI, with the latter being what's loaded when the load + * happens. + */ + +#ifndef nsSimpleNestedURI_h__ +#define nsSimpleNestedURI_h__ + +#include "nsCOMPtr.h" +#include "nsSimpleURI.h" +#include "nsINestedURI.h" +#include "nsIURIMutator.h" + +namespace mozilla { +namespace net { + +class nsSimpleNestedURI : public nsSimpleURI, public nsINestedURI { + protected: + nsSimpleNestedURI() = default; + explicit nsSimpleNestedURI(nsIURI* innerURI); + + ~nsSimpleNestedURI() = default; + + public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_NSINESTEDURI + + // Overrides for various methods nsSimpleURI implements follow. + + // nsSimpleURI overrides + virtual nsresult EqualsInternal(nsIURI* other, + RefHandlingEnum refHandlingMode, + bool* result) override; + virtual nsSimpleURI* StartClone(RefHandlingEnum refHandlingMode, + const nsACString& newRef) override; + NS_IMETHOD Mutate(nsIURIMutator** _retval) override; + NS_IMETHOD_(void) Serialize(ipc::URIParams& aParams) override; + + // nsISerializable overrides + NS_IMETHOD Read(nsIObjectInputStream* aStream) override; + NS_IMETHOD Write(nsIObjectOutputStream* aStream) override; + + protected: + nsCOMPtr<nsIURI> mInnerURI; + + nsresult SetPathQueryRef(const nsACString& aPathQueryRef) override; + nsresult SetQuery(const nsACString& aQuery) override; + nsresult SetRef(const nsACString& aRef) override; + bool Deserialize(const mozilla::ipc::URIParams&); + nsresult ReadPrivate(nsIObjectInputStream* stream); + + public: + class Mutator final : public nsIURIMutator, + public BaseURIMutator<nsSimpleNestedURI>, + public nsISerializable, + public nsINestedURIMutator { + NS_DECL_ISUPPORTS + NS_FORWARD_SAFE_NSIURISETTERS_RET(mURI) + + explicit Mutator() = default; + + private: + virtual ~Mutator() = default; + + [[nodiscard]] NS_IMETHOD Deserialize( + const mozilla::ipc::URIParams& aParams) override { + return InitFromIPCParams(aParams); + } + + NS_IMETHOD + Write(nsIObjectOutputStream* aOutputStream) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + + [[nodiscard]] NS_IMETHOD Read(nsIObjectInputStream* aStream) override { + return InitFromInputStream(aStream); + } + + [[nodiscard]] NS_IMETHOD Finalize(nsIURI** aURI) override { + mURI.forget(aURI); + return NS_OK; + } + + [[nodiscard]] NS_IMETHOD SetSpec(const nsACString& aSpec, + nsIURIMutator** aMutator) override { + if (aMutator) { + NS_ADDREF(*aMutator = this); + } + return InitFromSpec(aSpec); + } + + [[nodiscard]] NS_IMETHOD Init(nsIURI* innerURI) override { + mURI = new nsSimpleNestedURI(innerURI); + return NS_OK; + } + + friend class nsSimpleNestedURI; + }; + + friend BaseURIMutator<nsSimpleNestedURI>; +}; + +} // namespace net +} // namespace mozilla + +#endif /* nsSimpleNestedURI_h__ */ diff --git a/netwerk/base/nsSimpleStreamListener.cpp b/netwerk/base/nsSimpleStreamListener.cpp new file mode 100644 index 0000000000..beed8a9f40 --- /dev/null +++ b/netwerk/base/nsSimpleStreamListener.cpp @@ -0,0 +1,69 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "nsSimpleStreamListener.h" + +namespace mozilla { +namespace net { + +// +//---------------------------------------------------------------------------- +// nsISupports implementation... +//---------------------------------------------------------------------------- +// +NS_IMPL_ISUPPORTS(nsSimpleStreamListener, nsISimpleStreamListener, + nsIStreamListener, nsIRequestObserver) + +// +//---------------------------------------------------------------------------- +// nsIRequestObserver implementation... +//---------------------------------------------------------------------------- +// +NS_IMETHODIMP +nsSimpleStreamListener::OnStartRequest(nsIRequest* aRequest) { + return mObserver ? mObserver->OnStartRequest(aRequest) : NS_OK; +} + +NS_IMETHODIMP +nsSimpleStreamListener::OnStopRequest(nsIRequest* request, nsresult aStatus) { + return mObserver ? mObserver->OnStopRequest(request, aStatus) : NS_OK; +} + +// +//---------------------------------------------------------------------------- +// nsIStreamListener implementation... +//---------------------------------------------------------------------------- +// +NS_IMETHODIMP +nsSimpleStreamListener::OnDataAvailable(nsIRequest* request, + nsIInputStream* aSource, + uint64_t aOffset, uint32_t aCount) { + uint32_t writeCount; + nsresult rv = mSink->WriteFrom(aSource, aCount, &writeCount); + // + // Equate zero bytes read and NS_SUCCEEDED to stopping the read. + // + if (NS_SUCCEEDED(rv) && (writeCount == 0)) return NS_BASE_STREAM_CLOSED; + return rv; +} + +// +//---------------------------------------------------------------------------- +// nsISimpleStreamListener implementation... +//---------------------------------------------------------------------------- +// +NS_IMETHODIMP +nsSimpleStreamListener::Init(nsIOutputStream* aSink, + nsIRequestObserver* aObserver) { + MOZ_ASSERT(aSink, "null output stream"); + + mSink = aSink; + mObserver = aObserver; + + return NS_OK; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/nsSimpleStreamListener.h b/netwerk/base/nsSimpleStreamListener.h new file mode 100644 index 0000000000..890b49f61b --- /dev/null +++ b/netwerk/base/nsSimpleStreamListener.h @@ -0,0 +1,35 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef nsSimpleStreamListener_h__ +#define nsSimpleStreamListener_h__ + +#include "nsISimpleStreamListener.h" +#include "nsIOutputStream.h" +#include "nsCOMPtr.h" + +namespace mozilla { +namespace net { + +class nsSimpleStreamListener : public nsISimpleStreamListener { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIREQUESTOBSERVER + NS_DECL_NSISTREAMLISTENER + NS_DECL_NSISIMPLESTREAMLISTENER + + nsSimpleStreamListener() = default; + + protected: + virtual ~nsSimpleStreamListener() = default; + + nsCOMPtr<nsIOutputStream> mSink; + nsCOMPtr<nsIRequestObserver> mObserver; +}; + +} // namespace net +} // namespace mozilla + +#endif diff --git a/netwerk/base/nsSimpleURI.cpp b/netwerk/base/nsSimpleURI.cpp new file mode 100644 index 0000000000..5361de2e93 --- /dev/null +++ b/netwerk/base/nsSimpleURI.cpp @@ -0,0 +1,744 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "mozilla/DebugOnly.h" + +#undef LOG +#include "IPCMessageUtils.h" + +#include "nsSimpleURI.h" +#include "nscore.h" +#include "nsString.h" +#include "plstr.h" +#include "nsURLHelper.h" +#include "nsNetCID.h" +#include "nsIObjectInputStream.h" +#include "nsIObjectOutputStream.h" +#include "nsEscape.h" +#include "nsError.h" +#include "mozilla/MemoryReporting.h" +#include "mozilla/TextUtils.h" +#include "mozilla/ipc/URIUtils.h" +#include "nsIClassInfoImpl.h" +#include "nsIURIMutator.h" +#include "mozilla/net/MozURL.h" + +using namespace mozilla::ipc; + +namespace mozilla { +namespace net { + +static NS_DEFINE_CID(kThisSimpleURIImplementationCID, + NS_THIS_SIMPLEURI_IMPLEMENTATION_CID); + +/* static */ +already_AddRefed<nsSimpleURI> nsSimpleURI::From(nsIURI* aURI) { + RefPtr<nsSimpleURI> uri; + nsresult rv = aURI->QueryInterface(kThisSimpleURIImplementationCID, + getter_AddRefs(uri)); + if (NS_FAILED(rv)) { + return nullptr; + } + + return uri.forget(); +} + +NS_IMPL_CLASSINFO(nsSimpleURI, nullptr, nsIClassInfo::THREADSAFE, + NS_SIMPLEURI_CID) +// Empty CI getter. We only need nsIClassInfo for Serialization +NS_IMPL_CI_INTERFACE_GETTER0(nsSimpleURI) + +//////////////////////////////////////////////////////////////////////////////// +// nsSimpleURI methods: + +nsSimpleURI::nsSimpleURI() : mIsRefValid(false), mIsQueryValid(false) {} + +NS_IMPL_ADDREF(nsSimpleURI) +NS_IMPL_RELEASE(nsSimpleURI) +NS_INTERFACE_TABLE_HEAD(nsSimpleURI) + NS_INTERFACE_TABLE(nsSimpleURI, nsIURI, nsISerializable) + NS_INTERFACE_TABLE_TO_MAP_SEGUE + NS_IMPL_QUERY_CLASSINFO(nsSimpleURI) + if (aIID.Equals(kThisSimpleURIImplementationCID)) + foundInterface = static_cast<nsIURI*>(this); + else + NS_INTERFACE_MAP_ENTRY(nsISizeOf) +NS_INTERFACE_MAP_END + +//////////////////////////////////////////////////////////////////////////////// +// nsISerializable methods: + +NS_IMETHODIMP +nsSimpleURI::Read(nsIObjectInputStream* aStream) { + MOZ_ASSERT_UNREACHABLE("Use nsIURIMutator.read() instead"); + return NS_ERROR_NOT_IMPLEMENTED; +} + +nsresult nsSimpleURI::ReadPrivate(nsIObjectInputStream* aStream) { + nsresult rv; + + bool isMutable; + rv = aStream->ReadBoolean(&isMutable); + if (NS_FAILED(rv)) return rv; + Unused << isMutable; + + rv = aStream->ReadCString(mScheme); + if (NS_FAILED(rv)) return rv; + + rv = aStream->ReadCString(mPath); + if (NS_FAILED(rv)) return rv; + + bool isRefValid; + rv = aStream->ReadBoolean(&isRefValid); + if (NS_FAILED(rv)) return rv; + mIsRefValid = isRefValid; + + if (isRefValid) { + rv = aStream->ReadCString(mRef); + if (NS_FAILED(rv)) return rv; + } else { + mRef.Truncate(); // invariant: mRef should be empty when it's not valid + } + + bool isQueryValid; + rv = aStream->ReadBoolean(&isQueryValid); + if (NS_FAILED(rv)) return rv; + mIsQueryValid = isQueryValid; + + if (isQueryValid) { + rv = aStream->ReadCString(mQuery); + if (NS_FAILED(rv)) return rv; + } else { + mQuery.Truncate(); // invariant: mQuery should be empty when it's not valid + } + + return NS_OK; +} + +NS_IMETHODIMP +nsSimpleURI::Write(nsIObjectOutputStream* aStream) { + nsresult rv; + + rv = aStream->WriteBoolean(false); // former mMutable + if (NS_FAILED(rv)) return rv; + + rv = aStream->WriteStringZ(mScheme.get()); + if (NS_FAILED(rv)) return rv; + + rv = aStream->WriteStringZ(mPath.get()); + if (NS_FAILED(rv)) return rv; + + rv = aStream->WriteBoolean(mIsRefValid); + if (NS_FAILED(rv)) return rv; + + if (mIsRefValid) { + rv = aStream->WriteStringZ(mRef.get()); + if (NS_FAILED(rv)) return rv; + } + + rv = aStream->WriteBoolean(mIsQueryValid); + if (NS_FAILED(rv)) return rv; + + if (mIsQueryValid) { + rv = aStream->WriteStringZ(mQuery.get()); + if (NS_FAILED(rv)) return rv; + } + + return NS_OK; +} + +void nsSimpleURI::Serialize(URIParams& aParams) { + SimpleURIParams params; + + params.scheme() = mScheme; + params.path() = mPath; + + if (mIsRefValid) { + params.ref() = mRef; + } else { + params.ref().SetIsVoid(true); + } + + if (mIsQueryValid) { + params.query() = mQuery; + } else { + params.query().SetIsVoid(true); + } + + aParams = params; +} + +bool nsSimpleURI::Deserialize(const URIParams& aParams) { + if (aParams.type() != URIParams::TSimpleURIParams) { + NS_ERROR("Received unknown parameters from the other process!"); + return false; + } + + const SimpleURIParams& params = aParams.get_SimpleURIParams(); + + mScheme = params.scheme(); + mPath = params.path(); + + if (params.ref().IsVoid()) { + mRef.Truncate(); + mIsRefValid = false; + } else { + mRef = params.ref(); + mIsRefValid = true; + } + + if (params.query().IsVoid()) { + mQuery.Truncate(); + mIsQueryValid = false; + } else { + mQuery = params.query(); + mIsQueryValid = true; + } + + return true; +} + +//////////////////////////////////////////////////////////////////////////////// +// nsIURI methods: + +NS_IMETHODIMP +nsSimpleURI::GetSpec(nsACString& result) { + if (!result.Assign(mScheme, fallible) || !result.Append(":"_ns, fallible) || + !result.Append(mPath, fallible)) { + return NS_ERROR_OUT_OF_MEMORY; + } + + if (mIsQueryValid) { + if (!result.Append("?"_ns, fallible) || !result.Append(mQuery, fallible)) { + return NS_ERROR_OUT_OF_MEMORY; + } + } else { + MOZ_ASSERT(mQuery.IsEmpty(), "mIsQueryValid/mQuery invariant broken"); + } + + if (mIsRefValid) { + if (!result.Append("#"_ns, fallible) || !result.Append(mRef, fallible)) { + return NS_ERROR_OUT_OF_MEMORY; + } + } else { + MOZ_ASSERT(mRef.IsEmpty(), "mIsRefValid/mRef invariant broken"); + } + + return NS_OK; +} + +// result may contain unescaped UTF-8 characters +NS_IMETHODIMP +nsSimpleURI::GetSpecIgnoringRef(nsACString& result) { + result = mScheme + ":"_ns + mPath; + if (mIsQueryValid) { + result += "?"_ns + mQuery; + } + return NS_OK; +} + +NS_IMETHODIMP +nsSimpleURI::GetDisplaySpec(nsACString& aUnicodeSpec) { + return GetSpec(aUnicodeSpec); +} + +NS_IMETHODIMP +nsSimpleURI::GetDisplayHostPort(nsACString& aUnicodeHostPort) { + return GetHostPort(aUnicodeHostPort); +} + +NS_IMETHODIMP +nsSimpleURI::GetDisplayHost(nsACString& aUnicodeHost) { + return GetHost(aUnicodeHost); +} + +NS_IMETHODIMP +nsSimpleURI::GetDisplayPrePath(nsACString& aPrePath) { + return GetPrePath(aPrePath); +} + +NS_IMETHODIMP +nsSimpleURI::GetHasRef(bool* result) { + *result = mIsRefValid; + return NS_OK; +} + +nsresult nsSimpleURI::SetSpecInternal(const nsACString& aSpec) { + nsresult rv = net_ExtractURLScheme(aSpec, mScheme); + if (NS_FAILED(rv)) { + return rv; + } + + nsAutoCString spec; + rv = net_FilterAndEscapeURI(aSpec, esc_OnlyNonASCII, spec); + if (NS_FAILED(rv)) { + return rv; + } + + int32_t colonPos = spec.FindChar(':'); + MOZ_ASSERT(colonPos != kNotFound, "A colon should be in this string"); + // This sets mPath, mQuery and mRef. + return SetPathQueryRefEscaped(Substring(spec, colonPos + 1), + /* aNeedsEscape = */ false); +} + +NS_IMETHODIMP +nsSimpleURI::GetScheme(nsACString& result) { + result = mScheme; + return NS_OK; +} + +nsresult nsSimpleURI::SetScheme(const nsACString& scheme) { + const nsPromiseFlatCString& flat = PromiseFlatCString(scheme); + if (!net_IsValidScheme(flat)) { + NS_WARNING("the given url scheme contains invalid characters"); + return NS_ERROR_MALFORMED_URI; + } + + mScheme = scheme; + ToLowerCase(mScheme); + return NS_OK; +} + +NS_IMETHODIMP +nsSimpleURI::GetPrePath(nsACString& result) { + result = mScheme + ":"_ns; + return NS_OK; +} + +NS_IMETHODIMP +nsSimpleURI::GetUserPass(nsACString& result) { return NS_ERROR_FAILURE; } + +nsresult nsSimpleURI::SetUserPass(const nsACString& userPass) { + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP +nsSimpleURI::GetUsername(nsACString& result) { return NS_ERROR_FAILURE; } + +nsresult nsSimpleURI::SetUsername(const nsACString& userName) { + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP +nsSimpleURI::GetPassword(nsACString& result) { return NS_ERROR_FAILURE; } + +nsresult nsSimpleURI::SetPassword(const nsACString& password) { + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP +nsSimpleURI::GetHostPort(nsACString& result) { + // Note: Audit all callers before changing this to return an empty + // string -- CAPS and UI code may depend on this throwing. + // Note: If this is changed, change GetAsciiHostPort as well. + return NS_ERROR_FAILURE; +} + +nsresult nsSimpleURI::SetHostPort(const nsACString& result) { + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP +nsSimpleURI::GetHost(nsACString& result) { + // Note: Audit all callers before changing this to return an empty + // string -- CAPS and UI code depend on this throwing. + return NS_ERROR_FAILURE; +} + +nsresult nsSimpleURI::SetHost(const nsACString& host) { + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP +nsSimpleURI::GetPort(int32_t* result) { + // Note: Audit all callers before changing this to return an empty + // string -- CAPS and UI code may depend on this throwing. + return NS_ERROR_FAILURE; +} + +nsresult nsSimpleURI::SetPort(int32_t port) { return NS_ERROR_FAILURE; } + +NS_IMETHODIMP +nsSimpleURI::GetPathQueryRef(nsACString& result) { + result = mPath; + if (mIsQueryValid) { + result += "?"_ns + mQuery; + } + if (mIsRefValid) { + result += "#"_ns + mRef; + } + + return NS_OK; +} + +nsresult nsSimpleURI::SetPathQueryRef(const nsACString& aPath) { + return SetPathQueryRefEscaped(aPath, true); +} +nsresult nsSimpleURI::SetPathQueryRefEscaped(const nsACString& aPath, + bool aNeedsEscape) { + nsresult rv; + nsAutoCString path; + if (aNeedsEscape) { + rv = NS_EscapeURL(aPath, esc_OnlyNonASCII, path, fallible); + if (NS_FAILED(rv)) { + return rv; + } + } else { + if (!path.Assign(aPath, fallible)) { + return NS_ERROR_OUT_OF_MEMORY; + } + } + + int32_t queryPos = path.FindChar('?'); + int32_t hashPos = path.FindChar('#'); + + if (queryPos != kNotFound && hashPos != kNotFound && hashPos < queryPos) { + queryPos = kNotFound; + } + + nsAutoCString query; + if (queryPos != kNotFound) { + query.Assign(Substring(path, queryPos)); + path.Truncate(queryPos); + } + + nsAutoCString hash; + if (hashPos != kNotFound) { + if (query.IsEmpty()) { + hash.Assign(Substring(path, hashPos)); + path.Truncate(hashPos); + } else { + // We have to search the hash character in the query + hashPos = query.FindChar('#'); + hash.Assign(Substring(query, hashPos)); + query.Truncate(hashPos); + } + } + + mIsQueryValid = false; + mQuery.Truncate(); + + mIsRefValid = false; + mRef.Truncate(); + + // The path + if (!mPath.Assign(path, fallible)) { + return NS_ERROR_OUT_OF_MEMORY; + } + + rv = SetQuery(query); + if (NS_FAILED(rv)) { + return rv; + } + + return SetRef(hash); +} + +NS_IMETHODIMP +nsSimpleURI::GetRef(nsACString& result) { + if (!mIsRefValid) { + MOZ_ASSERT(mRef.IsEmpty(), "mIsRefValid/mRef invariant broken"); + result.Truncate(); + } else { + result = mRef; + } + + return NS_OK; +} + +// NOTE: SetRef("") removes our ref, whereas SetRef("#") sets it to the empty +// string (and will result in .spec and .path having a terminal #). +nsresult nsSimpleURI::SetRef(const nsACString& aRef) { + nsAutoCString ref; + nsresult rv = + NS_EscapeURL(aRef, esc_OnlyNonASCII | esc_Spaces, ref, fallible); + if (NS_FAILED(rv)) { + return rv; + } + + if (ref.IsEmpty()) { + // Empty string means to remove ref completely. + mIsRefValid = false; + mRef.Truncate(); // invariant: mRef should be empty when it's not valid + return NS_OK; + } + + mIsRefValid = true; + + // Gracefully skip initial hash + if (ref[0] == '#') { + mRef = Substring(ref, 1); + } else { + mRef = ref; + } + + return NS_OK; +} + +NS_IMETHODIMP +nsSimpleURI::Equals(nsIURI* other, bool* result) { + return EqualsInternal(other, eHonorRef, result); +} + +NS_IMETHODIMP +nsSimpleURI::EqualsExceptRef(nsIURI* other, bool* result) { + return EqualsInternal(other, eIgnoreRef, result); +} + +/* virtual */ +nsresult nsSimpleURI::EqualsInternal( + nsIURI* other, nsSimpleURI::RefHandlingEnum refHandlingMode, bool* result) { + NS_ENSURE_ARG_POINTER(other); + MOZ_ASSERT(result, "null pointer"); + + RefPtr<nsSimpleURI> otherUri; + nsresult rv = other->QueryInterface(kThisSimpleURIImplementationCID, + getter_AddRefs(otherUri)); + if (NS_FAILED(rv)) { + *result = false; + return NS_OK; + } + + *result = EqualsInternal(otherUri, refHandlingMode); + return NS_OK; +} + +bool nsSimpleURI::EqualsInternal(nsSimpleURI* otherUri, + RefHandlingEnum refHandlingMode) { + bool result = (mScheme == otherUri->mScheme && mPath == otherUri->mPath); + + if (result) { + result = (mIsQueryValid == otherUri->mIsQueryValid && + (!mIsQueryValid || mQuery == otherUri->mQuery)); + } + + if (result && refHandlingMode == eHonorRef) { + result = (mIsRefValid == otherUri->mIsRefValid && + (!mIsRefValid || mRef == otherUri->mRef)); + } + + return result; +} + +NS_IMETHODIMP +nsSimpleURI::SchemeIs(const char* i_Scheme, bool* o_Equals) { + MOZ_ASSERT(o_Equals, "null pointer"); + if (!i_Scheme) { + *o_Equals = false; + return NS_OK; + } + + const char* this_scheme = mScheme.get(); + + // mScheme is guaranteed to be lower case. + if (*i_Scheme == *this_scheme || *i_Scheme == (*this_scheme - ('a' - 'A'))) { + *o_Equals = PL_strcasecmp(this_scheme, i_Scheme) ? false : true; + } else { + *o_Equals = false; + } + + return NS_OK; +} + +/* virtual */ nsSimpleURI* nsSimpleURI::StartClone( + nsSimpleURI::RefHandlingEnum refHandlingMode, const nsACString& newRef) { + nsSimpleURI* url = new nsSimpleURI(); + SetRefOnClone(url, refHandlingMode, newRef); + return url; +} + +/* virtual */ +void nsSimpleURI::SetRefOnClone(nsSimpleURI* url, + nsSimpleURI::RefHandlingEnum refHandlingMode, + const nsACString& newRef) { + if (refHandlingMode == eHonorRef) { + url->mRef = mRef; + url->mIsRefValid = mIsRefValid; + } else if (refHandlingMode == eReplaceRef) { + url->SetRef(newRef); + } +} + +nsresult nsSimpleURI::Clone(nsIURI** result) { + return CloneInternal(eHonorRef, ""_ns, result); +} + +nsresult nsSimpleURI::CloneInternal( + nsSimpleURI::RefHandlingEnum refHandlingMode, const nsACString& newRef, + nsIURI** result) { + RefPtr<nsSimpleURI> url = StartClone(refHandlingMode, newRef); + if (!url) return NS_ERROR_OUT_OF_MEMORY; + + url->mScheme = mScheme; + url->mPath = mPath; + + url->mIsQueryValid = mIsQueryValid; + if (url->mIsQueryValid) { + url->mQuery = mQuery; + } + + url.forget(result); + return NS_OK; +} + +NS_IMETHODIMP +nsSimpleURI::Resolve(const nsACString& relativePath, nsACString& result) { + nsAutoCString scheme; + nsresult rv = net_ExtractURLScheme(relativePath, scheme); + if (NS_SUCCEEDED(rv)) { + result = relativePath; + return NS_OK; + } + + nsAutoCString spec; + rv = GetAsciiSpec(spec); + if (NS_WARN_IF(NS_FAILED(rv))) { + // If getting the spec fails for some reason, preserve behaviour and just + // return the relative path. + result = relativePath; + return NS_OK; + } + + RefPtr<MozURL> url; + rv = MozURL::Init(getter_AddRefs(url), spec); + if (NS_WARN_IF(NS_FAILED(rv))) { + // If parsing the current url fails, we revert to the previous behaviour + // and just return the relative path. + result = relativePath; + return NS_OK; + } + + RefPtr<MozURL> url2; + rv = MozURL::Init(getter_AddRefs(url2), relativePath, url); + if (NS_WARN_IF(NS_FAILED(rv))) { + // If parsing the relative url fails, we revert to the previous behaviour + // and just return the relative path. + result = relativePath; + return NS_OK; + } + + result = url2->Spec(); + return NS_OK; +} + +NS_IMETHODIMP +nsSimpleURI::GetAsciiSpec(nsACString& aResult) { + nsresult rv = GetSpec(aResult); + if (NS_FAILED(rv)) return rv; + MOZ_ASSERT(IsAscii(aResult), "The spec should be ASCII"); + return NS_OK; +} + +NS_IMETHODIMP +nsSimpleURI::GetAsciiHostPort(nsACString& result) { + // XXX This behavior mimics GetHostPort. + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP +nsSimpleURI::GetAsciiHost(nsACString& result) { + result.Truncate(); + return NS_OK; +} + +//---------------------------------------------------------------------------- +// nsSimpleURI::nsISizeOf +//---------------------------------------------------------------------------- + +size_t nsSimpleURI::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const { + return mScheme.SizeOfExcludingThisIfUnshared(aMallocSizeOf) + + mPath.SizeOfExcludingThisIfUnshared(aMallocSizeOf) + + mQuery.SizeOfExcludingThisIfUnshared(aMallocSizeOf) + + mRef.SizeOfExcludingThisIfUnshared(aMallocSizeOf); +} + +size_t nsSimpleURI::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const { + return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf); +} + +NS_IMETHODIMP +nsSimpleURI::GetFilePath(nsACString& aFilePath) { + aFilePath = mPath; + return NS_OK; +} + +nsresult nsSimpleURI::SetFilePath(const nsACString& aFilePath) { + if (mPath.IsEmpty() || mPath.First() != '/') { + // cannot-be-a-base + return NS_ERROR_MALFORMED_URI; + } + const char* current = aFilePath.BeginReading(); + const char* end = aFilePath.EndReading(); + + // Only go up to the first ? or # symbol + for (; current < end; ++current) { + if (*current == '?' || *current == '#') { + break; + } + } + return SetPathQueryRef( + nsDependentCSubstring(aFilePath.BeginReading(), current)); +} + +NS_IMETHODIMP +nsSimpleURI::GetQuery(nsACString& aQuery) { + if (!mIsQueryValid) { + MOZ_ASSERT(mQuery.IsEmpty(), "mIsQueryValid/mQuery invariant broken"); + aQuery.Truncate(); + } else { + aQuery = mQuery; + } + return NS_OK; +} + +nsresult nsSimpleURI::SetQuery(const nsACString& aQuery) { + nsAutoCString query; + nsresult rv = NS_EscapeURL(aQuery, esc_OnlyNonASCII, query, fallible); + if (NS_FAILED(rv)) { + return rv; + } + + if (query.IsEmpty()) { + // Empty string means to remove query completely. + mIsQueryValid = false; + mQuery.Truncate(); // invariant: mQuery should be empty when it's not valid + return NS_OK; + } + + mIsQueryValid = true; + + // Gracefully skip initial question mark + if (query[0] == '?') { + mQuery = Substring(query, 1); + } else { + mQuery = query; + } + + return NS_OK; +} + +nsresult nsSimpleURI::SetQueryWithEncoding(const nsACString& aQuery, + const Encoding* aEncoding) { + return SetQuery(aQuery); +} + +// Queries this list of interfaces. If none match, it queries mURI. +NS_IMPL_NSIURIMUTATOR_ISUPPORTS(nsSimpleURI::Mutator, nsIURISetters, + nsIURIMutator, nsISerializable) + +NS_IMETHODIMP +nsSimpleURI::Mutate(nsIURIMutator** aMutator) { + RefPtr<nsSimpleURI::Mutator> mutator = new nsSimpleURI::Mutator(); + nsresult rv = mutator->InitFromURI(this); + if (NS_FAILED(rv)) { + return rv; + } + mutator.forget(aMutator); + return NS_OK; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/nsSimpleURI.h b/netwerk/base/nsSimpleURI.h new file mode 100644 index 0000000000..4b32075927 --- /dev/null +++ b/netwerk/base/nsSimpleURI.h @@ -0,0 +1,143 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef nsSimpleURI_h__ +#define nsSimpleURI_h__ + +#include "mozilla/MemoryReporting.h" +#include "nsIURI.h" +#include "nsISerializable.h" +#include "nsString.h" +#include "nsIClassInfo.h" +#include "nsISizeOf.h" +#include "nsIURIMutator.h" + +namespace mozilla { +namespace net { + +#define NS_THIS_SIMPLEURI_IMPLEMENTATION_CID \ + { /* 0b9bb0c2-fee6-470b-b9b9-9fd9462b5e19 */ \ + 0x0b9bb0c2, 0xfee6, 0x470b, { \ + 0xb9, 0xb9, 0x9f, 0xd9, 0x46, 0x2b, 0x5e, 0x19 \ + } \ + } + +class nsSimpleURI : public nsIURI, public nsISerializable, public nsISizeOf { + protected: + nsSimpleURI(); + virtual ~nsSimpleURI() = default; + + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIURI + NS_DECL_NSISERIALIZABLE + + static already_AddRefed<nsSimpleURI> From(nsIURI* aURI); + + // nsSimpleURI methods: + + bool Equals(nsSimpleURI* aOther) { return EqualsInternal(aOther, eHonorRef); } + + // nsISizeOf + // Among the sub-classes that inherit (directly or indirectly) from + // nsSimpleURI, measurement of the following members may be added later if + // DMD finds it is worthwhile: + // - nsJSURI: mBaseURI + // - nsSimpleNestedURI: mInnerURI + // - nsBlobURI: mPrincipal + virtual size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const override; + virtual size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const override; + + protected: + // enum used in a few places to specify how .ref attribute should be handled + enum RefHandlingEnum { eIgnoreRef, eHonorRef, eReplaceRef }; + + virtual nsresult Clone(nsIURI** aURI); + virtual nsresult SetSpecInternal(const nsACString& input); + virtual nsresult SetScheme(const nsACString& input); + virtual nsresult SetUserPass(const nsACString& input); + nsresult SetUsername(const nsACString& input); + virtual nsresult SetPassword(const nsACString& input); + virtual nsresult SetHostPort(const nsACString& aValue); + virtual nsresult SetHost(const nsACString& input); + virtual nsresult SetPort(int32_t port); + virtual nsresult SetPathQueryRef(const nsACString& input); + virtual nsresult SetRef(const nsACString& input); + virtual nsresult SetFilePath(const nsACString& input); + virtual nsresult SetQuery(const nsACString& input); + virtual nsresult SetQueryWithEncoding(const nsACString& input, + const Encoding* encoding); + nsresult ReadPrivate(nsIObjectInputStream* stream); + + // Helper to share code between Equals methods. + virtual nsresult EqualsInternal(nsIURI* other, + RefHandlingEnum refHandlingMode, + bool* result); + + // Helper to be used by inherited classes who want to test + // equality given an assumed nsSimpleURI. This must NOT check + // the passed-in other for QI to our CID. + bool EqualsInternal(nsSimpleURI* otherUri, RefHandlingEnum refHandlingMode); + + // Used by StartClone (and versions of StartClone in subclasses) to + // handle the ref in the right way for clones. + void SetRefOnClone(nsSimpleURI* url, RefHandlingEnum refHandlingMode, + const nsACString& newRef); + + // NOTE: This takes the refHandlingMode as an argument because + // nsSimpleNestedURI's specialized version needs to know how to clone + // its inner URI. + virtual nsSimpleURI* StartClone(RefHandlingEnum refHandlingMode, + const nsACString& newRef); + + // Helper to share code between Clone methods. + virtual nsresult CloneInternal(RefHandlingEnum refHandlingMode, + const nsACString& newRef, nsIURI** clone); + + nsresult SetPathQueryRefEscaped(const nsACString& aPath, bool aNeedsEscape); + + bool Deserialize(const mozilla::ipc::URIParams&); + + nsCString mScheme; + nsCString mPath; // NOTE: mPath does not include ref, as an optimization + nsCString mRef; // so that URIs with different refs can share string data. + nsCString + mQuery; // so that URLs with different querys can share string data. + bool mMutable; + bool mIsRefValid; // To distinguish between empty-ref and no-ref. + bool mIsQueryValid; // To distinguish between empty-query and no-query. + + public: + class Mutator final : public nsIURIMutator, + public BaseURIMutator<nsSimpleURI>, + public nsISerializable { + NS_DECL_ISUPPORTS + NS_FORWARD_SAFE_NSIURISETTERS_RET(mURI) + NS_DEFINE_NSIMUTATOR_COMMON + + NS_IMETHOD + Write(nsIObjectOutputStream* aOutputStream) override { + return NS_ERROR_NOT_IMPLEMENTED; + } + + [[nodiscard]] NS_IMETHOD Read(nsIObjectInputStream* aStream) override { + return InitFromInputStream(aStream); + } + + explicit Mutator() = default; + + private: + virtual ~Mutator() = default; + + friend class nsSimpleURI; + }; + + friend BaseURIMutator<nsSimpleURI>; +}; + +} // namespace net +} // namespace mozilla + +#endif // nsSimpleURI_h__ diff --git a/netwerk/base/nsSocketTransport2.cpp b/netwerk/base/nsSocketTransport2.cpp new file mode 100644 index 0000000000..e029c8e6bd --- /dev/null +++ b/netwerk/base/nsSocketTransport2.cpp @@ -0,0 +1,3610 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=4 sw=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 "nsSocketTransport2.h" + +#include "mozilla/Attributes.h" +#include "mozilla/SyncRunnable.h" +#include "mozilla/Telemetry.h" +#include "nsIOService.h" +#include "nsStreamUtils.h" +#include "nsNetSegmentUtils.h" +#include "nsNetAddr.h" +#include "nsTransportUtils.h" +#include "nsProxyInfo.h" +#include "nsNetCID.h" +#include "nsNetUtil.h" +#include "nsCOMPtr.h" +#include "plstr.h" +#include "prerr.h" +#include "IOActivityMonitor.h" +#include "NSSErrorsService.h" +#include "mozilla/dom/ToJSValue.h" +#include "mozilla/net/NeckoChild.h" +#include "nsThreadUtils.h" +#include "nsSocketProviderService.h" +#include "nsISocketProvider.h" +#include "nsISSLSocketControl.h" +#include "nsIPipe.h" +#include "nsIClassInfoImpl.h" +#include "nsURLHelper.h" +#include "nsIDNSService.h" +#include "nsIDNSRecord.h" +#include "nsIDNSByTypeRecord.h" +#include "nsICancelable.h" +#include "NetworkDataCountLayer.h" +#include "QuicSocketControl.h" +#include "TCPFastOpenLayer.h" +#include <algorithm> +#include "sslexp.h" +#include "mozilla/net/SSLTokensCache.h" +#include "mozilla/StaticPrefs_network.h" + +#include "nsPrintfCString.h" +#include "xpcpublic.h" + +#if defined(FUZZING) +# include "FuzzyLayer.h" +# include "FuzzySecurityInfo.h" +# include "mozilla/StaticPrefs_fuzzing.h" +#endif + +#if defined(XP_WIN) +# include "ShutdownLayer.h" +#endif + +/* Following inclusions required for keepalive config not supported by NSPR. */ +#include "private/pprio.h" +#if defined(XP_WIN) +# include <winsock2.h> +# include <mstcpip.h> +#elif defined(XP_UNIX) +# include <errno.h> +# include <netinet/tcp.h> +#endif +/* End keepalive config inclusions. */ + +#define SUCCESSFUL_CONNECTING_TO_IPV4_ADDRESS 0 +#define UNSUCCESSFUL_CONNECTING_TO_IPV4_ADDRESS 1 +#define SUCCESSFUL_CONNECTING_TO_IPV6_ADDRESS 2 +#define UNSUCCESSFUL_CONNECTING_TO_IPV6_ADDRESS 3 + +//----------------------------------------------------------------------------- + +static NS_DEFINE_CID(kDNSServiceCID, NS_DNSSERVICE_CID); + +//----------------------------------------------------------------------------- + +namespace mozilla { +namespace net { + +class nsSocketEvent : public Runnable { + public: + nsSocketEvent(nsSocketTransport* transport, uint32_t type, + nsresult status = NS_OK, nsISupports* param = nullptr) + : Runnable("net::nsSocketEvent"), + mTransport(transport), + mType(type), + mStatus(status), + mParam(param) {} + + NS_IMETHOD Run() override { + mTransport->OnSocketEvent(mType, mStatus, mParam); + return NS_OK; + } + + private: + RefPtr<nsSocketTransport> mTransport; + + uint32_t mType; + nsresult mStatus; + nsCOMPtr<nsISupports> mParam; +}; + +//----------------------------------------------------------------------------- + +//#define TEST_CONNECT_ERRORS +#ifdef TEST_CONNECT_ERRORS +# include <stdlib.h> +static PRErrorCode RandomizeConnectError(PRErrorCode code) { + // + // To test out these errors, load http://www.yahoo.com/. It should load + // correctly despite the random occurrence of these errors. + // + int n = rand(); + if (n > RAND_MAX / 2) { + struct { + PRErrorCode err_code; + const char* err_name; + } errors[] = { + // + // These errors should be recoverable provided there is another + // IP address in mDNSRecord. + // + {PR_CONNECT_REFUSED_ERROR, "PR_CONNECT_REFUSED_ERROR"}, + {PR_CONNECT_TIMEOUT_ERROR, "PR_CONNECT_TIMEOUT_ERROR"}, + // + // This error will cause this socket transport to error out; + // however, if the consumer is HTTP, then the HTTP transaction + // should be restarted when this error occurs. + // + {PR_CONNECT_RESET_ERROR, "PR_CONNECT_RESET_ERROR"}, + }; + n = n % (sizeof(errors) / sizeof(errors[0])); + code = errors[n].err_code; + SOCKET_LOG(("simulating NSPR error %d [%s]\n", code, errors[n].err_name)); + } + return code; +} +#endif + +//----------------------------------------------------------------------------- + +nsresult ErrorAccordingToNSPR(PRErrorCode errorCode) { + nsresult rv = NS_ERROR_FAILURE; + switch (errorCode) { + case PR_WOULD_BLOCK_ERROR: + rv = NS_BASE_STREAM_WOULD_BLOCK; + break; + case PR_CONNECT_ABORTED_ERROR: + case PR_CONNECT_RESET_ERROR: + rv = NS_ERROR_NET_RESET; + break; + case PR_END_OF_FILE_ERROR: // XXX document this correlation + rv = NS_ERROR_NET_INTERRUPT; + break; + case PR_CONNECT_REFUSED_ERROR: + // We lump the following NSPR codes in with PR_CONNECT_REFUSED_ERROR. We + // could get better diagnostics by adding distinct XPCOM error codes for + // each of these, but there are a lot of places in Gecko that check + // specifically for NS_ERROR_CONNECTION_REFUSED, all of which would need to + // be checked. + case PR_NETWORK_UNREACHABLE_ERROR: + case PR_HOST_UNREACHABLE_ERROR: + case PR_ADDRESS_NOT_AVAILABLE_ERROR: + // Treat EACCES as a soft error since (at least on Linux) connect() returns + // EACCES when an IPv6 connection is blocked by a firewall. See bug 270784. + case PR_NO_ACCESS_RIGHTS_ERROR: + rv = NS_ERROR_CONNECTION_REFUSED; + break; + case PR_ADDRESS_NOT_SUPPORTED_ERROR: + rv = NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED; + break; + case PR_IO_TIMEOUT_ERROR: + case PR_CONNECT_TIMEOUT_ERROR: + rv = NS_ERROR_NET_TIMEOUT; + break; + case PR_OUT_OF_MEMORY_ERROR: + // These really indicate that the descriptor table filled up, or that the + // kernel ran out of network buffers - but nobody really cares which part of + // the system ran out of memory. + case PR_PROC_DESC_TABLE_FULL_ERROR: + case PR_SYS_DESC_TABLE_FULL_ERROR: + case PR_INSUFFICIENT_RESOURCES_ERROR: + rv = NS_ERROR_OUT_OF_MEMORY; + break; + case PR_ADDRESS_IN_USE_ERROR: + rv = NS_ERROR_SOCKET_ADDRESS_IN_USE; + break; + // These filename-related errors can arise when using Unix-domain sockets. + case PR_FILE_NOT_FOUND_ERROR: + rv = NS_ERROR_FILE_NOT_FOUND; + break; + case PR_IS_DIRECTORY_ERROR: + rv = NS_ERROR_FILE_IS_DIRECTORY; + break; + case PR_LOOP_ERROR: + rv = NS_ERROR_FILE_UNRESOLVABLE_SYMLINK; + break; + case PR_NAME_TOO_LONG_ERROR: + rv = NS_ERROR_FILE_NAME_TOO_LONG; + break; + case PR_NO_DEVICE_SPACE_ERROR: + rv = NS_ERROR_FILE_NO_DEVICE_SPACE; + break; + case PR_NOT_DIRECTORY_ERROR: + rv = NS_ERROR_FILE_NOT_DIRECTORY; + break; + case PR_READ_ONLY_FILESYSTEM_ERROR: + rv = NS_ERROR_FILE_READ_ONLY; + break; + case PR_BAD_ADDRESS_ERROR: + rv = NS_ERROR_UNKNOWN_HOST; + break; + default: + if (psm::IsNSSErrorCode(errorCode)) { + rv = psm::GetXPCOMFromNSSError(errorCode); + } + break; + + // NSPR's socket code can return these, but they're not worth breaking out + // into their own error codes, distinct from NS_ERROR_FAILURE: + // + // PR_BAD_DESCRIPTOR_ERROR + // PR_INVALID_ARGUMENT_ERROR + // PR_NOT_SOCKET_ERROR + // PR_NOT_TCP_SOCKET_ERROR + // These would indicate a bug internal to the component. + // + // PR_PROTOCOL_NOT_SUPPORTED_ERROR + // This means that we can't use the given "protocol" (like + // IPPROTO_TCP or IPPROTO_UDP) with a socket of the given type. As + // above, this indicates an internal bug. + // + // PR_IS_CONNECTED_ERROR + // This indicates that we've applied a system call like 'bind' or + // 'connect' to a socket that is already connected. The socket + // components manage each file descriptor's state, and in some cases + // handle this error result internally. We shouldn't be returning + // this to our callers. + // + // PR_IO_ERROR + // This is so vague that NS_ERROR_FAILURE is just as good. + } + SOCKET_LOG(("ErrorAccordingToNSPR [in=%d out=%" PRIx32 "]\n", errorCode, + static_cast<uint32_t>(rv))); + return rv; +} + +//----------------------------------------------------------------------------- +// socket input stream impl +//----------------------------------------------------------------------------- + +nsSocketInputStream::nsSocketInputStream(nsSocketTransport* trans) + : mTransport(trans), + mReaderRefCnt(0), + mCondition(NS_OK), + mCallbackFlags(0), + mByteCount(0) {} + +// called on the socket transport thread... +// +// condition : failure code if socket has been closed +// +void nsSocketInputStream::OnSocketReady(nsresult condition) { + SOCKET_LOG(("nsSocketInputStream::OnSocketReady [this=%p cond=%" PRIx32 "]\n", + this, static_cast<uint32_t>(condition))); + + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + nsCOMPtr<nsIInputStreamCallback> callback; + { + MutexAutoLock lock(mTransport->mLock); + + // update condition, but be careful not to erase an already + // existing error condition. + if (NS_SUCCEEDED(mCondition)) mCondition = condition; + + // ignore event if only waiting for closure and not closed. + if (NS_FAILED(mCondition) || !(mCallbackFlags & WAIT_CLOSURE_ONLY)) { + callback = std::move(mCallback); + mCallbackFlags = 0; + } + } + + if (callback) callback->OnInputStreamReady(this); +} + +NS_IMPL_QUERY_INTERFACE(nsSocketInputStream, nsIInputStream, + nsIAsyncInputStream) + +NS_IMETHODIMP_(MozExternalRefCountType) +nsSocketInputStream::AddRef() { + ++mReaderRefCnt; + return mTransport->AddRef(); +} + +NS_IMETHODIMP_(MozExternalRefCountType) +nsSocketInputStream::Release() { + if (--mReaderRefCnt == 0) Close(); + return mTransport->Release(); +} + +NS_IMETHODIMP +nsSocketInputStream::Close() { return CloseWithStatus(NS_BASE_STREAM_CLOSED); } + +NS_IMETHODIMP +nsSocketInputStream::Available(uint64_t* avail) { + SOCKET_LOG(("nsSocketInputStream::Available [this=%p]\n", this)); + + *avail = 0; + + PRFileDesc* fd; + { + MutexAutoLock lock(mTransport->mLock); + + if (NS_FAILED(mCondition)) return mCondition; + + fd = mTransport->GetFD_Locked(); + if (!fd) return NS_OK; + } + + // cannot hold lock while calling NSPR. (worried about the fact that PSM + // synchronously proxies notifications over to the UI thread, which could + // mistakenly try to re-enter this code.) + int32_t n = PR_Available(fd); + + // PSM does not implement PR_Available() so do a best approximation of it + // with MSG_PEEK + if ((n == -1) && (PR_GetError() == PR_NOT_IMPLEMENTED_ERROR)) { + char c; + + n = PR_Recv(fd, &c, 1, PR_MSG_PEEK, 0); + SOCKET_LOG( + ("nsSocketInputStream::Available [this=%p] " + "using PEEK backup n=%d]\n", + this, n)); + } + + nsresult rv; + { + MutexAutoLock lock(mTransport->mLock); + + mTransport->ReleaseFD_Locked(fd); + + if (n >= 0) + *avail = n; + else { + PRErrorCode code = PR_GetError(); + if (code == PR_WOULD_BLOCK_ERROR) return NS_OK; + mCondition = ErrorAccordingToNSPR(code); + } + rv = mCondition; + } + if (NS_FAILED(rv)) mTransport->OnInputClosed(rv); + return rv; +} + +NS_IMETHODIMP +nsSocketInputStream::Read(char* buf, uint32_t count, uint32_t* countRead) { + SOCKET_LOG(("nsSocketInputStream::Read [this=%p count=%u]\n", this, count)); + + *countRead = 0; + + PRFileDesc* fd = nullptr; + { + MutexAutoLock lock(mTransport->mLock); + + if (NS_FAILED(mCondition)) + return (mCondition == NS_BASE_STREAM_CLOSED) ? NS_OK : mCondition; + + fd = mTransport->GetFD_Locked(); + if (!fd) return NS_BASE_STREAM_WOULD_BLOCK; + } + + SOCKET_LOG((" calling PR_Read [count=%u]\n", count)); + + // cannot hold lock while calling NSPR. (worried about the fact that PSM + // synchronously proxies notifications over to the UI thread, which could + // mistakenly try to re-enter this code.) + int32_t n = PR_Read(fd, buf, count); + + SOCKET_LOG((" PR_Read returned [n=%d]\n", n)); + + nsresult rv = NS_OK; + { + MutexAutoLock lock(mTransport->mLock); + +#ifdef ENABLE_SOCKET_TRACING + if (n > 0) mTransport->TraceInBuf(buf, n); +#endif + + mTransport->ReleaseFD_Locked(fd); + + if (n > 0) + mByteCount += (*countRead = n); + else if (n < 0) { + PRErrorCode code = PR_GetError(); + if (code == PR_WOULD_BLOCK_ERROR) return NS_BASE_STREAM_WOULD_BLOCK; + mCondition = ErrorAccordingToNSPR(code); + } + rv = mCondition; + } + if (NS_FAILED(rv)) mTransport->OnInputClosed(rv); + + // only send this notification if we have indeed read some data. + // see bug 196827 for an example of why this is important. + if (n > 0) mTransport->SendStatus(NS_NET_STATUS_RECEIVING_FROM); + return rv; +} + +NS_IMETHODIMP +nsSocketInputStream::ReadSegments(nsWriteSegmentFun writer, void* closure, + uint32_t count, uint32_t* countRead) { + // socket stream is unbuffered + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsSocketInputStream::IsNonBlocking(bool* nonblocking) { + *nonblocking = true; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketInputStream::CloseWithStatus(nsresult reason) { + SOCKET_LOG(("nsSocketInputStream::CloseWithStatus [this=%p reason=%" PRIx32 + "]\n", + this, static_cast<uint32_t>(reason))); + + // may be called from any thread + + nsresult rv; + { + MutexAutoLock lock(mTransport->mLock); + + if (NS_SUCCEEDED(mCondition)) + rv = mCondition = reason; + else + rv = NS_OK; + } + if (NS_FAILED(rv)) mTransport->OnInputClosed(rv); + return NS_OK; +} + +NS_IMETHODIMP +nsSocketInputStream::AsyncWait(nsIInputStreamCallback* callback, uint32_t flags, + uint32_t amount, nsIEventTarget* target) { + SOCKET_LOG(("nsSocketInputStream::AsyncWait [this=%p]\n", this)); + + bool hasError = false; + { + MutexAutoLock lock(mTransport->mLock); + + if (callback && target) { + // + // build event proxy + // + mCallback = NS_NewInputStreamReadyEvent("nsSocketInputStream::AsyncWait", + callback, target); + } else + mCallback = callback; + mCallbackFlags = flags; + + hasError = NS_FAILED(mCondition); + } // unlock mTransport->mLock + + if (hasError) { + // OnSocketEvent will call OnInputStreamReady with an error code after + // going through the event loop. We do this because most socket callers + // do not expect AsyncWait() to synchronously execute the OnInputStreamReady + // callback. + mTransport->PostEvent(nsSocketTransport::MSG_INPUT_PENDING); + } else { + mTransport->OnInputPending(); + } + + return NS_OK; +} + +//----------------------------------------------------------------------------- +// socket output stream impl +//----------------------------------------------------------------------------- + +nsSocketOutputStream::nsSocketOutputStream(nsSocketTransport* trans) + : mTransport(trans), + mWriterRefCnt(0), + mCondition(NS_OK), + mCallbackFlags(0), + mByteCount(0) {} + +// called on the socket transport thread... +// +// condition : failure code if socket has been closed +// +void nsSocketOutputStream::OnSocketReady(nsresult condition) { + SOCKET_LOG(("nsSocketOutputStream::OnSocketReady [this=%p cond=%" PRIx32 + "]\n", + this, static_cast<uint32_t>(condition))); + + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + nsCOMPtr<nsIOutputStreamCallback> callback; + { + MutexAutoLock lock(mTransport->mLock); + + // update condition, but be careful not to erase an already + // existing error condition. + if (NS_SUCCEEDED(mCondition)) mCondition = condition; + + // ignore event if only waiting for closure and not closed. + if (NS_FAILED(mCondition) || !(mCallbackFlags & WAIT_CLOSURE_ONLY)) { + callback = std::move(mCallback); + mCallbackFlags = 0; + } + } + + if (callback) callback->OnOutputStreamReady(this); +} + +NS_IMPL_QUERY_INTERFACE(nsSocketOutputStream, nsIOutputStream, + nsIAsyncOutputStream) + +NS_IMETHODIMP_(MozExternalRefCountType) +nsSocketOutputStream::AddRef() { + ++mWriterRefCnt; + return mTransport->AddRef(); +} + +NS_IMETHODIMP_(MozExternalRefCountType) +nsSocketOutputStream::Release() { + if (--mWriterRefCnt == 0) Close(); + return mTransport->Release(); +} + +NS_IMETHODIMP +nsSocketOutputStream::Close() { return CloseWithStatus(NS_BASE_STREAM_CLOSED); } + +NS_IMETHODIMP +nsSocketOutputStream::Flush() { return NS_OK; } + +NS_IMETHODIMP +nsSocketOutputStream::Write(const char* buf, uint32_t count, + uint32_t* countWritten) { + SOCKET_LOG(("nsSocketOutputStream::Write [this=%p count=%u]\n", this, count)); + + *countWritten = 0; + + // A write of 0 bytes can be used to force the initial SSL handshake, so do + // not reject that. + + PRFileDesc* fd = nullptr; + bool fastOpenInProgress; + { + MutexAutoLock lock(mTransport->mLock); + + if (NS_FAILED(mCondition)) return mCondition; + + fd = mTransport->GetFD_LockedAlsoDuringFastOpen(); + if (!fd) return NS_BASE_STREAM_WOULD_BLOCK; + + fastOpenInProgress = mTransport->FastOpenInProgress(); + } + + if (fastOpenInProgress) { + // If we are in the fast open phase, we should not write more data + // than TCPFastOpenLayer can accept. If we write more data, this data + // will be buffered in tls and we want to avoid that. + uint32_t availableSpace = TCPFastOpenGetBufferSizeLeft(fd); + count = (count > availableSpace) ? availableSpace : count; + if (!count) { + { + MutexAutoLock lock(mTransport->mLock); + mTransport->ReleaseFD_Locked(fd); + } + return NS_BASE_STREAM_WOULD_BLOCK; + } + } + + SOCKET_LOG((" calling PR_Write [count=%u]\n", count)); + + // cannot hold lock while calling NSPR. (worried about the fact that PSM + // synchronously proxies notifications over to the UI thread, which could + // mistakenly try to re-enter this code.) + int32_t n = PR_Write(fd, buf, count); + + SOCKET_LOG((" PR_Write returned [n=%d]\n", n)); + + nsresult rv = NS_OK; + { + MutexAutoLock lock(mTransport->mLock); + +#ifdef ENABLE_SOCKET_TRACING + if (n > 0) mTransport->TraceOutBuf(buf, n); +#endif + + mTransport->ReleaseFD_Locked(fd); + + if (n > 0) + mByteCount += (*countWritten = n); + else if (n < 0) { + PRErrorCode code = PR_GetError(); + if (code == PR_WOULD_BLOCK_ERROR) return NS_BASE_STREAM_WOULD_BLOCK; + mCondition = ErrorAccordingToNSPR(code); + } + rv = mCondition; + } + if (NS_FAILED(rv)) mTransport->OnOutputClosed(rv); + + // only send this notification if we have indeed written some data. + // see bug 196827 for an example of why this is important. + // During a fast open we are actually not sending data, the data will be + // only buffered in the TCPFastOpenLayer. Therefore we will call + // SendStatus(NS_NET_STATUS_SENDING_TO) when we really send data (i.e. when + // TCPFastOpenFinish is called. + if ((n > 0) && !fastOpenInProgress) { + mTransport->SendStatus(NS_NET_STATUS_SENDING_TO); + } + + return rv; +} + +NS_IMETHODIMP +nsSocketOutputStream::WriteSegments(nsReadSegmentFun reader, void* closure, + uint32_t count, uint32_t* countRead) { + // socket stream is unbuffered + return NS_ERROR_NOT_IMPLEMENTED; +} + +nsresult nsSocketOutputStream::WriteFromSegments( + nsIInputStream* input, void* closure, const char* fromSegment, + uint32_t offset, uint32_t count, uint32_t* countRead) { + nsSocketOutputStream* self = (nsSocketOutputStream*)closure; + return self->Write(fromSegment, count, countRead); +} + +NS_IMETHODIMP +nsSocketOutputStream::WriteFrom(nsIInputStream* stream, uint32_t count, + uint32_t* countRead) { + return stream->ReadSegments(WriteFromSegments, this, count, countRead); +} + +NS_IMETHODIMP +nsSocketOutputStream::IsNonBlocking(bool* nonblocking) { + *nonblocking = true; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketOutputStream::CloseWithStatus(nsresult reason) { + SOCKET_LOG(("nsSocketOutputStream::CloseWithStatus [this=%p reason=%" PRIx32 + "]\n", + this, static_cast<uint32_t>(reason))); + + // may be called from any thread + + nsresult rv; + { + MutexAutoLock lock(mTransport->mLock); + + if (NS_SUCCEEDED(mCondition)) + rv = mCondition = reason; + else + rv = NS_OK; + } + if (NS_FAILED(rv)) mTransport->OnOutputClosed(rv); + return NS_OK; +} + +NS_IMETHODIMP +nsSocketOutputStream::AsyncWait(nsIOutputStreamCallback* callback, + uint32_t flags, uint32_t amount, + nsIEventTarget* target) { + SOCKET_LOG(("nsSocketOutputStream::AsyncWait [this=%p]\n", this)); + + { + MutexAutoLock lock(mTransport->mLock); + + if (callback && target) { + // + // build event proxy + // + mCallback = NS_NewOutputStreamReadyEvent(callback, target); + } else + mCallback = callback; + + mCallbackFlags = flags; + } + mTransport->OnOutputPending(); + return NS_OK; +} + +//----------------------------------------------------------------------------- +// socket transport impl +//----------------------------------------------------------------------------- + +nsSocketTransport::nsSocketTransport() + : mPort(0), + mProxyPort(0), + mOriginPort(0), + mProxyTransparent(false), + mProxyTransparentResolvesHost(false), + mHttpsProxy(false), + mConnectionFlags(0), + mResetFamilyPreference(false), + mTlsFlags(0), + mReuseAddrPort(false), + mState(STATE_CLOSED), + mAttached(false), + mInputClosed(true), + mOutputClosed(true), + mResolving(false), + mEchConfigUsed(false), + mResolvedByTRR(false), + mNetAddrIsSet(false), + mSelfAddrIsSet(false), + mLock("nsSocketTransport.mLock"), + mFD(this), + mFDref(0), + mFDconnected(false), + mFDFastOpenInProgress(false), + mSocketTransportService(gSocketTransportService), + mInput(this), + mOutput(this), + mLingerPolarity(false), + mLingerTimeout(0), + mQoSBits(0x00), + mKeepaliveEnabled(false), + mKeepaliveIdleTimeS(-1), + mKeepaliveRetryIntervalS(-1), + mKeepaliveProbeCount(-1), + mFastOpenCallback(nullptr), + mFastOpenLayerHasBufferedData(false), + mFastOpenStatus(TFO_NOT_SET), + mFirstRetryError(NS_OK), + mDoNotRetryToConnect(false), + mUsingQuic(false) { + this->mNetAddr.raw.family = 0; + this->mNetAddr.inet = {}; + this->mSelfAddr.raw.family = 0; + this->mSelfAddr.inet = {}; + SOCKET_LOG(("creating nsSocketTransport @%p\n", this)); + + mTimeouts[TIMEOUT_CONNECT] = UINT16_MAX; // no timeout + mTimeouts[TIMEOUT_READ_WRITE] = UINT16_MAX; // no timeout +} + +nsSocketTransport::~nsSocketTransport() { + SOCKET_LOG(("destroying nsSocketTransport @%p\n", this)); +} + +nsresult nsSocketTransport::Init(const nsTArray<nsCString>& types, + const nsACString& host, uint16_t port, + const nsACString& hostRoute, + uint16_t portRoute, + nsIProxyInfo* givenProxyInfo) { + nsCOMPtr<nsProxyInfo> proxyInfo; + if (givenProxyInfo) { + proxyInfo = do_QueryInterface(givenProxyInfo); + NS_ENSURE_ARG(proxyInfo); + } + + // init socket type info + + mOriginHost = host; + mOriginPort = port; + if (!hostRoute.IsEmpty()) { + mHost = hostRoute; + mPort = portRoute; + } else { + mHost = host; + mPort = port; + } + + // A subtle check we don't enter this method more than once for the socket + // transport lifetime. Disable on TSan builds to prevent race checking, we + // don't want an atomic here for perf reasons! +#ifndef MOZ_TSAN + MOZ_ASSERT(!mPortRemappingApplied); +#endif // !MOZ_TSAN + + if (proxyInfo) { + mHttpsProxy = proxyInfo->IsHTTPS(); + } + + const char* proxyType = nullptr; + mProxyInfo = proxyInfo; + if (proxyInfo) { + mProxyPort = proxyInfo->Port(); + mProxyHost = proxyInfo->Host(); + // grab proxy type (looking for "socks" for example) + proxyType = proxyInfo->Type(); + if (proxyType && (proxyInfo->IsHTTP() || proxyInfo->IsHTTPS() || + proxyInfo->IsDirect() || !strcmp(proxyType, "unknown"))) { + proxyType = nullptr; + } + } + + SOCKET_LOG1( + ("nsSocketTransport::Init [this=%p host=%s:%hu origin=%s:%d " + "proxy=%s:%hu]\n", + this, mHost.get(), mPort, mOriginHost.get(), mOriginPort, + mProxyHost.get(), mProxyPort)); + + // include proxy type as a socket type if proxy type is not "http" + uint32_t typeCount = types.Length() + (proxyType != nullptr); + if (!typeCount) return NS_OK; + + // if we have socket types, then the socket provider service had + // better exist! + nsresult rv; + nsCOMPtr<nsISocketProviderService> spserv = + nsSocketProviderService::GetOrCreate(); + + if (!mTypes.SetCapacity(typeCount, fallible)) { + return NS_ERROR_OUT_OF_MEMORY; + } + + // now verify that each socket type has a registered socket provider. + for (uint32_t i = 0, type = 0; i < typeCount; ++i) { + // store socket types + if (i == 0 && proxyType) + mTypes.AppendElement(proxyType); + else + mTypes.AppendElement(types[type++]); + + // quic does not have a socketProvider. + if (!mTypes[i].EqualsLiteral("quic")) { + nsCOMPtr<nsISocketProvider> provider; + rv = spserv->GetSocketProvider(mTypes[i].get(), getter_AddRefs(provider)); + if (NS_FAILED(rv)) { + NS_WARNING("no registered socket provider"); + return rv; + } + } + + // note if socket type corresponds to a transparent proxy + // XXX don't hardcode SOCKS here (use proxy info's flags instead). + if (mTypes[i].EqualsLiteral("socks") || mTypes[i].EqualsLiteral("socks4")) { + mProxyTransparent = true; + + if (proxyInfo->Flags() & nsIProxyInfo::TRANSPARENT_PROXY_RESOLVES_HOST) { + // we want the SOCKS layer to send the hostname + // and port to the proxy and let it do the DNS. + mProxyTransparentResolvesHost = true; + } + } + } + + return NS_OK; +} + +#if defined(XP_UNIX) +nsresult nsSocketTransport::InitWithFilename(const char* filename) { + return InitWithName(filename, strlen(filename)); +} + +nsresult nsSocketTransport::InitWithName(const char* name, size_t length) { + if (length > sizeof(mNetAddr.local.path) - 1) { + return NS_ERROR_FILE_NAME_TOO_LONG; + } + + if (!name[0] && length > 1) { + // name is abstract address name that is supported on Linux only +# if defined(XP_LINUX) + mHost.Assign(name + 1, length - 1); +# else + return NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED; +# endif + } else { + // The name isn't abstract socket address. So this is Unix domain + // socket that has file path. + mHost.Assign(name, length); + } + mPort = 0; + + mNetAddr.local.family = AF_LOCAL; + memcpy(mNetAddr.local.path, name, length); + mNetAddr.local.path[length] = '\0'; + mNetAddrIsSet = true; + + return NS_OK; +} +#endif + +nsresult nsSocketTransport::InitWithConnectedSocket(PRFileDesc* fd, + const NetAddr* addr) { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + NS_ASSERTION(!mFD.IsInitialized(), "already initialized"); + + char buf[kNetAddrMaxCStrBufSize]; + addr->ToStringBuffer(buf, sizeof(buf)); + mHost.Assign(buf); + + uint16_t port; + if (addr->raw.family == AF_INET) + port = addr->inet.port; + else if (addr->raw.family == AF_INET6) + port = addr->inet6.port; + else + port = 0; + mPort = ntohs(port); + + memcpy(&mNetAddr, addr, sizeof(NetAddr)); + + mPollFlags = (PR_POLL_READ | PR_POLL_WRITE | PR_POLL_EXCEPT); + mState = STATE_TRANSFERRING; + SetSocketName(fd); + mNetAddrIsSet = true; + + { + MutexAutoLock lock(mLock); + + mFD = fd; + mFDref = 1; + mFDconnected = true; + mPollTimeout = mTimeouts[TIMEOUT_READ_WRITE]; + } + + // make sure new socket is non-blocking + PRSocketOptionData opt; + opt.option = PR_SockOpt_Nonblocking; + opt.value.non_blocking = true; + PR_SetSocketOption(fd, &opt); + + SOCKET_LOG( + ("nsSocketTransport::InitWithConnectedSocket [this=%p addr=%s:%hu]\n", + this, mHost.get(), mPort)); + + // jump to InitiateSocket to get ourselves attached to the STS poll list. + return PostEvent(MSG_RETRY_INIT_SOCKET); +} + +nsresult nsSocketTransport::InitWithConnectedSocket(PRFileDesc* aFD, + const NetAddr* aAddr, + nsISupports* aSecInfo) { + mSecInfo = aSecInfo; + return InitWithConnectedSocket(aFD, aAddr); +} + +nsresult nsSocketTransport::PostEvent(uint32_t type, nsresult status, + nsISupports* param) { + SOCKET_LOG(("nsSocketTransport::PostEvent [this=%p type=%u status=%" PRIx32 + " param=%p]\n", + this, type, static_cast<uint32_t>(status), param)); + + nsCOMPtr<nsIRunnable> event = new nsSocketEvent(this, type, status, param); + if (!event) return NS_ERROR_OUT_OF_MEMORY; + + return mSocketTransportService->Dispatch(event, NS_DISPATCH_NORMAL); +} + +void nsSocketTransport::SendStatus(nsresult status) { + SOCKET_LOG1(("nsSocketTransport::SendStatus [this=%p status=%" PRIx32 "]\n", + this, static_cast<uint32_t>(status))); + + nsCOMPtr<nsITransportEventSink> sink; + uint64_t progress; + { + MutexAutoLock lock(mLock); + sink = mEventSink; + switch (status) { + case NS_NET_STATUS_SENDING_TO: + progress = mOutput.ByteCount(); + // If Fast Open is used, we buffer some data in TCPFastOpenLayer, + // This data can be only tls data or application data as well. + // socketTransport should send status only if it really has sent + // application data. socketTransport cannot query transaction for + // that info but it can know if transaction has send data if + // mOutput.ByteCount() is > 0. + if (progress == 0) { + return; + } + break; + case NS_NET_STATUS_RECEIVING_FROM: + progress = mInput.ByteCount(); + break; + default: + progress = 0; + break; + } + } + if (sink) { + sink->OnTransportStatus(this, status, progress, -1); + } +} + +nsresult nsSocketTransport::ResolveHost() { + SOCKET_LOG(( + "nsSocketTransport::ResolveHost [this=%p %s:%d%s] " + "mProxyTransparentResolvesHost=%d\n", + this, SocketHost().get(), SocketPort(), + mConnectionFlags & nsSocketTransport::BYPASS_CACHE ? " bypass cache" : "", + mProxyTransparentResolvesHost)); + + nsresult rv; + + if (!mProxyHost.IsEmpty()) { + if (!mProxyTransparent || mProxyTransparentResolvesHost) { +#if defined(XP_UNIX) + MOZ_ASSERT(!mNetAddrIsSet || mNetAddr.raw.family != AF_LOCAL, + "Unix domain sockets can't be used with proxies"); +#endif + // When not resolving mHost locally, we still want to ensure that + // it only contains valid characters. See bug 304904 for details. + // Sometimes the end host is not yet known and mHost is * + if (!net_IsValidHostName(mHost) && !mHost.EqualsLiteral("*")) { + SOCKET_LOG((" invalid hostname %s\n", mHost.get())); + return NS_ERROR_UNKNOWN_HOST; + } + } + if (mProxyTransparentResolvesHost) { + // Name resolution is done on the server side. Just pretend + // client resolution is complete, this will get picked up later. + // since we don't need to do DNS now, we bypass the resolving + // step by initializing mNetAddr to an empty address, but we + // must keep the port. The SOCKS IO layer will use the hostname + // we send it when it's created, rather than the empty address + // we send with the connect call. + mState = STATE_RESOLVING; + mNetAddr.raw.family = AF_INET; + mNetAddr.inet.port = htons(SocketPort()); + mNetAddr.inet.ip = htonl(INADDR_ANY); + return PostEvent(MSG_DNS_LOOKUP_COMPLETE, NS_OK, nullptr); + } + } + + nsCOMPtr<nsIDNSService> dns = nullptr; + auto initTask = [&dns]() { dns = do_GetService(kDNSServiceCID); }; + if (!NS_IsMainThread()) { + // Forward to the main thread synchronously. + RefPtr<nsIThread> mainThread = do_GetMainThread(); + if (!mainThread) { + return NS_ERROR_FAILURE; + } + + SyncRunnable::DispatchToThread( + mainThread, + new SyncRunnable(NS_NewRunnableFunction( + "nsSocketTransport::ResolveHost->GetDNSService", initTask))); + } else { + initTask(); + } + if (!dns) { + return NS_ERROR_FAILURE; + } + + mResolving = true; + + uint32_t dnsFlags = 0; + if (mConnectionFlags & nsSocketTransport::BYPASS_CACHE) + dnsFlags = nsIDNSService::RESOLVE_BYPASS_CACHE; + if (mConnectionFlags & nsSocketTransport::REFRESH_CACHE) + dnsFlags = nsIDNSService::RESOLVE_REFRESH_CACHE; + if (mConnectionFlags & nsSocketTransport::DISABLE_IPV6) + dnsFlags |= nsIDNSService::RESOLVE_DISABLE_IPV6; + if (mConnectionFlags & nsSocketTransport::DISABLE_IPV4) + dnsFlags |= nsIDNSService::RESOLVE_DISABLE_IPV4; + if (mConnectionFlags & nsSocketTransport::DISABLE_TRR) + dnsFlags |= nsIDNSService::RESOLVE_DISABLE_TRR; + + if (mConnectionFlags & nsSocketTransport::USE_IP_HINT_ADDRESS) { + dnsFlags |= nsIDNSService::RESOLVE_IP_HINT; + } + + dnsFlags |= nsIDNSService::GetFlagsFromTRRMode( + nsISocketTransport::GetTRRModeFromFlags(mConnectionFlags)); + + // When we get here, we are not resolving using any configured proxy likely + // because of individual proxy setting on the request or because the host is + // excluded from proxying. Hence, force resolution despite global proxy-DNS + // configuration. + dnsFlags |= nsIDNSService::RESOLVE_IGNORE_SOCKS_DNS; + + NS_ASSERTION(!(dnsFlags & nsIDNSService::RESOLVE_DISABLE_IPV6) || + !(dnsFlags & nsIDNSService::RESOLVE_DISABLE_IPV4), + "Setting both RESOLVE_DISABLE_IPV6 and RESOLVE_DISABLE_IPV4"); + + SendStatus(NS_NET_STATUS_RESOLVING_HOST); + + if (!SocketHost().Equals(mOriginHost)) { + SOCKET_LOG(("nsSocketTransport %p origin %s doing dns for %s\n", this, + mOriginHost.get(), SocketHost().get())); + } + rv = + dns->AsyncResolveNative(SocketHost(), nsIDNSService::RESOLVE_TYPE_DEFAULT, + dnsFlags, nullptr, this, mSocketTransportService, + mOriginAttributes, getter_AddRefs(mDNSRequest)); + + if (NS_SUCCEEDED(rv)) { + SOCKET_LOG((" advancing to STATE_RESOLVING\n")); + mState = STATE_RESOLVING; + } + return rv; +} + +nsresult nsSocketTransport::BuildSocket(PRFileDesc*& fd, bool& proxyTransparent, + bool& usingSSL) { + SOCKET_LOG(("nsSocketTransport::BuildSocket [this=%p]\n", this)); + + nsresult rv = NS_OK; + + proxyTransparent = false; + usingSSL = false; + + if (mTypes.IsEmpty()) { + fd = PR_OpenTCPSocket(mNetAddr.raw.family); + if (!fd) { + SOCKET_LOG((" error creating TCP nspr socket [rv=%" PRIx32 "]\n", + static_cast<uint32_t>(rv))); + return NS_ERROR_OUT_OF_MEMORY; + } + return NS_OK; + } + +#if defined(XP_UNIX) + MOZ_ASSERT(!mNetAddrIsSet || mNetAddr.raw.family != AF_LOCAL, + "Unix domain sockets can't be used with socket types"); +#endif + + fd = nullptr; + + uint32_t controlFlags = 0; + if (mProxyTransparentResolvesHost) + controlFlags |= nsISocketProvider::PROXY_RESOLVES_HOST; + + if (mConnectionFlags & nsISocketTransport::ANONYMOUS_CONNECT) + controlFlags |= nsISocketProvider::ANONYMOUS_CONNECT; + + if (mConnectionFlags & nsISocketTransport::NO_PERMANENT_STORAGE) + controlFlags |= nsISocketProvider::NO_PERMANENT_STORAGE; + + if (mConnectionFlags & nsISocketTransport::BE_CONSERVATIVE) + controlFlags |= nsISocketProvider::BE_CONSERVATIVE; + + // by setting host to mOriginHost, instead of mHost we send the + // SocketProvider (e.g. PSM) the origin hostname but can still do DNS + // on an explicit alternate service host name + const char* host = mOriginHost.get(); + int32_t port = (int32_t)mOriginPort; + + if (mTypes[0].EqualsLiteral("quic")) { + fd = PR_OpenUDPSocket(mNetAddr.raw.family); + if (!fd) { + SOCKET_LOG((" error creating UDP nspr socket [rv=%" PRIx32 "]\n", + static_cast<uint32_t>(rv))); + return NS_ERROR_OUT_OF_MEMORY; + } + + mUsingQuic = true; + // Create security control and info object for quic. + RefPtr<QuicSocketControl> quicCtrl = new QuicSocketControl(controlFlags); + quicCtrl->SetHostName(mHttpsProxy ? mProxyHost.get() : host); + quicCtrl->SetPort(mHttpsProxy ? mProxyPort : port); + nsCOMPtr<nsISupports> secinfo; + quicCtrl->QueryInterface(NS_GET_IID(nsISupports), (void**)(&secinfo)); + + // remember security info and give notification callbacks to PSM... + nsCOMPtr<nsIInterfaceRequestor> callbacks; + { + MutexAutoLock lock(mLock); + mSecInfo = secinfo; + callbacks = mCallbacks; + SOCKET_LOG( + (" [secinfo=%p callbacks=%p]\n", mSecInfo.get(), mCallbacks.get())); + } + // don't call into PSM while holding mLock!! + quicCtrl->SetNotificationCallbacks(callbacks); + + return NS_OK; + } + + nsCOMPtr<nsISocketProviderService> spserv = + nsSocketProviderService::GetOrCreate(); + nsCOMPtr<nsIProxyInfo> proxyInfo = mProxyInfo; + + uint32_t i; + for (i = 0; i < mTypes.Length(); ++i) { + nsCOMPtr<nsISocketProvider> provider; + + SOCKET_LOG((" pushing io layer [%u:%s]\n", i, mTypes[i].get())); + + rv = spserv->GetSocketProvider(mTypes[i].get(), getter_AddRefs(provider)); + if (NS_FAILED(rv)) break; + + nsCOMPtr<nsISupports> secinfo; + if (i == 0) { + // if this is the first type, we'll want the + // service to allocate a new socket + + // Most layers _ESPECIALLY_ PSM want the origin name here as they + // will use it for secure checks, etc.. and any connection management + // differences between the origin name and the routed name can be + // taken care of via DNS. However, SOCKS is a special case as there is + // no DNS. in the case of SOCKS and PSM the PSM is a separate layer + // and receives the origin name. + const char* socketProviderHost = host; + int32_t socketProviderPort = port; + if (mProxyTransparentResolvesHost && + (mTypes[0].EqualsLiteral("socks") || + mTypes[0].EqualsLiteral("socks4"))) { + SOCKET_LOG(("SOCKS %d Host/Route override: %s:%d -> %s:%d\n", + mHttpsProxy, socketProviderHost, socketProviderPort, + mHost.get(), mPort)); + socketProviderHost = mHost.get(); + socketProviderPort = mPort; + } + + // when https proxying we want to just connect to the proxy as if + // it were the end host (i.e. expect the proxy's cert) + + rv = provider->NewSocket( + mNetAddr.raw.family, + mHttpsProxy ? mProxyHost.get() : socketProviderHost, + mHttpsProxy ? mProxyPort : socketProviderPort, proxyInfo, + mOriginAttributes, controlFlags, mTlsFlags, &fd, + getter_AddRefs(secinfo)); + + if (NS_SUCCEEDED(rv) && !fd) { + MOZ_ASSERT_UNREACHABLE( + "NewSocket succeeded but failed to " + "create a PRFileDesc"); + rv = NS_ERROR_UNEXPECTED; + } + } else { + // the socket has already been allocated, + // so we just want the service to add itself + // to the stack (such as pushing an io layer) + rv = provider->AddToSocket(mNetAddr.raw.family, host, port, proxyInfo, + mOriginAttributes, controlFlags, mTlsFlags, fd, + getter_AddRefs(secinfo)); + } + + // controlFlags = 0; not used below this point... + if (NS_FAILED(rv)) break; + + // if the service was ssl or starttls, we want to hold onto the socket + // info + bool isSSL = mTypes[i].EqualsLiteral("ssl"); + if (isSSL || mTypes[i].EqualsLiteral("starttls")) { + // remember security info and give notification callbacks to PSM... + nsCOMPtr<nsIInterfaceRequestor> callbacks; + { + MutexAutoLock lock(mLock); + mSecInfo = secinfo; + callbacks = mCallbacks; + SOCKET_LOG((" [secinfo=%p callbacks=%p]\n", mSecInfo.get(), + mCallbacks.get())); + } + // don't call into PSM while holding mLock!! + nsCOMPtr<nsISSLSocketControl> secCtrl(do_QueryInterface(secinfo)); + if (secCtrl) secCtrl->SetNotificationCallbacks(callbacks); + // remember if socket type is SSL so we can ProxyStartSSL if need be. + usingSSL = isSSL; + } else if (mTypes[i].EqualsLiteral("socks") || + mTypes[i].EqualsLiteral("socks4")) { + // since socks is transparent, any layers above + // it do not have to worry about proxy stuff + proxyInfo = nullptr; + proxyTransparent = true; + } + } + + if (NS_FAILED(rv)) { + SOCKET_LOG((" error pushing io layer [%u:%s rv=%" PRIx32 "]\n", i, + mTypes[i].get(), static_cast<uint32_t>(rv))); + if (fd) { + CloseSocket( + fd, mSocketTransportService->IsTelemetryEnabledAndNotSleepPhase()); + } + } + return rv; +} + +nsresult nsSocketTransport::InitiateSocket() { + SOCKET_LOG(("nsSocketTransport::InitiateSocket [this=%p]\n", this)); + + nsresult rv; + bool isLocal; + IsLocal(&isLocal); + + if (gIOService->IsNetTearingDown()) { + return NS_ERROR_ABORT; + } + if (gIOService->IsOffline()) { + if (!isLocal) return NS_ERROR_OFFLINE; + } else if (!isLocal) { +#ifdef DEBUG + // all IP networking has to be done from the parent + if (NS_SUCCEEDED(mCondition) && ((mNetAddr.raw.family == AF_INET) || + (mNetAddr.raw.family == AF_INET6))) { + MOZ_ASSERT(!IsNeckoChild()); + } +#endif + + if (NS_SUCCEEDED(mCondition) && xpc::AreNonLocalConnectionsDisabled() && + !(mNetAddr.IsIPAddrAny() || mNetAddr.IsIPAddrLocal() || + mNetAddr.IsIPAddrShared())) { + nsAutoCString ipaddr; + RefPtr<nsNetAddr> netaddr = new nsNetAddr(&mNetAddr); + netaddr->GetAddress(ipaddr); + fprintf_stderr( + stderr, + "FATAL ERROR: Non-local network connections are disabled and a " + "connection " + "attempt to %s (%s) was made.\nYou should only access hostnames " + "available via the test networking proxy (if running mochitests) " + "or from a test-specific httpd.js server (if running xpcshell " + "tests). " + "Browser services should be disabled or redirected to a local " + "server.\n", + mHost.get(), ipaddr.get()); + MOZ_CRASH("Attempting to connect to non-local address!"); + } + } + + // Hosts/Proxy Hosts that are Local IP Literals should not be speculatively + // connected - Bug 853423. + if (mConnectionFlags & nsISocketTransport::DISABLE_RFC1918 && + mNetAddr.IsIPAddrLocal()) { + if (SOCKET_LOG_ENABLED()) { + nsAutoCString netAddrCString; + netAddrCString.SetLength(kIPv6CStrBufSize); + if (!mNetAddr.ToStringBuffer(netAddrCString.BeginWriting(), + kIPv6CStrBufSize)) + netAddrCString = "<IP-to-string failed>"_ns; + SOCKET_LOG( + ("nsSocketTransport::InitiateSocket skipping " + "speculative connection for host [%s:%d] proxy " + "[%s:%d] with Local IP address [%s]", + mHost.get(), mPort, mProxyHost.get(), mProxyPort, + netAddrCString.get())); + } + mCondition = NS_ERROR_CONNECTION_REFUSED; + OnSocketDetached(nullptr); + return mCondition; + } + + // + // find out if it is going to be ok to attach another socket to the STS. + // if not then we have to wait for the STS to tell us that it is ok. + // the notification is asynchronous, which means that when we could be + // in a race to call AttachSocket once notified. for this reason, when + // we get notified, we just re-enter this function. as a result, we are + // sure to ask again before calling AttachSocket. in this way we deal + // with the race condition. though it isn't the most elegant solution, + // it is far simpler than trying to build a system that would guarantee + // FIFO ordering (which wouldn't even be that valuable IMO). see bug + // 194402 for more info. + // + if (!mSocketTransportService->CanAttachSocket()) { + nsCOMPtr<nsIRunnable> event = + new nsSocketEvent(this, MSG_RETRY_INIT_SOCKET); + if (!event) return NS_ERROR_OUT_OF_MEMORY; + return mSocketTransportService->NotifyWhenCanAttachSocket(event); + } + + // + // if we already have a connected socket, then just attach and return. + // + if (mFD.IsInitialized()) { + rv = mSocketTransportService->AttachSocket(mFD, this); + if (NS_SUCCEEDED(rv)) mAttached = true; + return rv; + } + + // + // create new socket fd, push io layers, etc. + // + PRFileDesc* fd; + bool proxyTransparent; + bool usingSSL; + + rv = BuildSocket(fd, proxyTransparent, usingSSL); + if (NS_FAILED(rv)) { + SOCKET_LOG( + (" BuildSocket failed [rv=%" PRIx32 "]\n", static_cast<uint32_t>(rv))); + return rv; + } + + // create proxy via IOActivityMonitor + IOActivityMonitor::MonitorSocket(fd); + +#ifdef FUZZING + if (StaticPrefs::fuzzing_necko_enabled()) { + rv = AttachFuzzyIOLayer(fd); + if (NS_FAILED(rv)) { + SOCKET_LOG(("Failed to attach fuzzing IOLayer [rv=%" PRIx32 "].\n", + static_cast<uint32_t>(rv))); + return rv; + } + SOCKET_LOG(("Successfully attached fuzzing IOLayer.\n")); + + if (usingSSL) { + mSecInfo = static_cast<nsISupports*>( + static_cast<nsISSLSocketControl*>(new FuzzySecurityInfo())); + } + } +#endif + + PRStatus status; + + // Make the socket non-blocking... + PRSocketOptionData opt; + opt.option = PR_SockOpt_Nonblocking; + opt.value.non_blocking = true; + status = PR_SetSocketOption(fd, &opt); + NS_ASSERTION(status == PR_SUCCESS, "unable to make socket non-blocking"); + + if (mUsingQuic) { + opt.option = PR_SockOpt_RecvBufferSize; + opt.value.recv_buffer_size = + StaticPrefs::network_http_http3_recvBufferSize(); + status = PR_SetSocketOption(fd, &opt); + if (status != PR_SUCCESS) { + SOCKET_LOG((" Couldn't set recv buffer size")); + } + } + + if (!mUsingQuic) { + if (mReuseAddrPort) { + SOCKET_LOG((" Setting port/addr reuse socket options\n")); + + // Set ReuseAddr for TCP sockets to enable having several + // sockets bound to same local IP and port + PRSocketOptionData opt_reuseaddr; + opt_reuseaddr.option = PR_SockOpt_Reuseaddr; + opt_reuseaddr.value.reuse_addr = PR_TRUE; + status = PR_SetSocketOption(fd, &opt_reuseaddr); + if (status != PR_SUCCESS) { + SOCKET_LOG((" Couldn't set reuse addr socket option: %d\n", status)); + } + + // And also set ReusePort for platforms supporting this socket option + PRSocketOptionData opt_reuseport; + opt_reuseport.option = PR_SockOpt_Reuseport; + opt_reuseport.value.reuse_port = PR_TRUE; + status = PR_SetSocketOption(fd, &opt_reuseport); + if (status != PR_SUCCESS && + PR_GetError() != PR_OPERATION_NOT_SUPPORTED_ERROR) { + SOCKET_LOG((" Couldn't set reuse port socket option: %d\n", status)); + } + } + + // disable the nagle algorithm - if we rely on it to coalesce writes into + // full packets the final packet of a multi segment POST/PUT or pipeline + // sequence is delayed a full rtt + opt.option = PR_SockOpt_NoDelay; + opt.value.no_delay = true; + PR_SetSocketOption(fd, &opt); + + // if the network.tcp.sendbuffer preference is set, use it to size SO_SNDBUF + // The Windows default of 8KB is too small and as of vista sp1, autotuning + // only applies to receive window + int32_t sndBufferSize; + mSocketTransportService->GetSendBufferSize(&sndBufferSize); + if (sndBufferSize > 0) { + opt.option = PR_SockOpt_SendBufferSize; + opt.value.send_buffer_size = sndBufferSize; + PR_SetSocketOption(fd, &opt); + } + + if (mQoSBits) { + opt.option = PR_SockOpt_IpTypeOfService; + opt.value.tos = mQoSBits; + PR_SetSocketOption(fd, &opt); + } + +#if defined(XP_WIN) + // The linger is turned off by default. This is not a hard close, but + // closesocket should return immediately and operating system tries to send + // remaining data for certain, implementation specific, amount of time. + // https://msdn.microsoft.com/en-us/library/ms739165.aspx + // + // Turn the linger option on an set the interval to 0. This will cause hard + // close of the socket. + opt.option = PR_SockOpt_Linger; + opt.value.linger.polarity = 1; + opt.value.linger.linger = 0; + PR_SetSocketOption(fd, &opt); +#endif + } + + // inform socket transport about this newly created socket... + rv = mSocketTransportService->AttachSocket(fd, this); + if (NS_FAILED(rv)) { + CloseSocket(fd, + mSocketTransportService->IsTelemetryEnabledAndNotSleepPhase()); + return rv; + } + mAttached = true; + + // assign mFD so that we can properly handle OnSocketDetached before we've + // established a connection. + { + MutexAutoLock lock(mLock); + mFD = fd; + mFDref = 1; + mFDconnected = false; + mPollTimeout = mTimeouts[TIMEOUT_CONNECT]; + } + + SOCKET_LOG((" advancing to STATE_CONNECTING\n")); + mState = STATE_CONNECTING; + SendStatus(NS_NET_STATUS_CONNECTING_TO); + + if (SOCKET_LOG_ENABLED()) { + char buf[kNetAddrMaxCStrBufSize]; + mNetAddr.ToStringBuffer(buf, sizeof(buf)); + SOCKET_LOG((" trying address: %s\n", buf)); + } + + // + // Initiate the connect() to the host... + // + PRNetAddr prAddr; + memset(&prAddr, 0, sizeof(prAddr)); + { + if (mBindAddr) { + MutexAutoLock lock(mLock); + NetAddrToPRNetAddr(mBindAddr.get(), &prAddr); + status = PR_Bind(fd, &prAddr); + if (status != PR_SUCCESS) { + return NS_ERROR_FAILURE; + } + mBindAddr = nullptr; + } + } + + NetAddrToPRNetAddr(&mNetAddr, &prAddr); + +#ifdef XP_WIN + // Find the real tcp socket and set non-blocking once again! + // Bug 1158189. + PRFileDesc* bottom = PR_GetIdentitiesLayer(fd, PR_NSPR_IO_LAYER); + if (bottom) { + PROsfd osfd = PR_FileDesc2NativeHandle(bottom); + u_long nonblocking = 1; + if (ioctlsocket(osfd, FIONBIO, &nonblocking) != 0) { + NS_WARNING("Socket could not be set non-blocking!"); + return NS_ERROR_FAILURE; + } + } +#endif + + nsCOMPtr<nsISSLSocketControl> secCtrl = do_QueryInterface(mSecInfo); + if (secCtrl) { + if (!mEchConfig.IsEmpty() && + !(mConnectionFlags & (DONT_TRY_ECH | BE_CONSERVATIVE))) { + SOCKET_LOG(("nsSocketTransport::InitiateSocket set echconfig.")); + rv = secCtrl->SetEchConfig(mEchConfig); + if (NS_FAILED(rv)) { + return rv; + } + mEchConfigUsed = true; + } + } + + if (mUsingQuic) { + // + // we pretend that we are connected! + // + if (PR_Connect(fd, &prAddr, NS_SOCKET_CONNECT_TIMEOUT) == PR_SUCCESS) { + OnSocketConnected(); + return NS_OK; + } + PRErrorCode code = PR_GetError(); + return ErrorAccordingToNSPR(code); + } + + // We use PRIntervalTime here because we need + // nsIOService::LastOfflineStateChange time and + // nsIOService::LastConectivityChange time to be atomic. + PRIntervalTime connectStarted = 0; + if (gSocketTransportService->IsTelemetryEnabledAndNotSleepPhase()) { + connectStarted = PR_IntervalNow(); + } + + bool tfo = false; + if (!mProxyTransparent && mFastOpenCallback && + mFastOpenCallback->FastOpenEnabled()) { + if (NS_SUCCEEDED(AttachTCPFastOpenIOLayer(fd))) { + tfo = true; + SOCKET_LOG( + ("nsSocketTransport::InitiateSocket TCP Fast Open " + "started [this=%p]\n", + this)); + } + } + + if (Telemetry::CanRecordPrereleaseData() || + Telemetry::CanRecordReleaseData()) { + if (NS_FAILED(AttachNetworkDataCountLayer(fd))) { + SOCKET_LOG( + ("nsSocketTransport::InitiateSocket " + "AttachNetworkDataCountLayer failed [this=%p]\n", + this)); + } + } + + bool connectCalled = true; // This is only needed for telemetry. + status = PR_Connect(fd, &prAddr, NS_SOCKET_CONNECT_TIMEOUT); + PRErrorCode code = PR_GetError(); + if (status == PR_SUCCESS) { + PR_SetFDInheritable(fd, false); + } + if ((status == PR_SUCCESS) && tfo) { + { + MutexAutoLock lock(mLock); + mFDFastOpenInProgress = true; + } + SOCKET_LOG(("Using TCP Fast Open.")); + rv = mFastOpenCallback->StartFastOpen(); + if (NS_FAILED(rv)) { + if (NS_SUCCEEDED(mCondition)) { + mCondition = rv; + } + mFastOpenCallback = nullptr; + MutexAutoLock lock(mLock); + mFDFastOpenInProgress = false; + return rv; + } + status = PR_FAILURE; + connectCalled = false; + bool fastOpenNotSupported = false; + TCPFastOpenFinish(fd, code, fastOpenNotSupported, mFastOpenStatus); + + // If we have sent data, trigger a socket status event. + if (mFastOpenStatus == TFO_DATA_SENT) { + SendStatus(NS_NET_STATUS_SENDING_TO); + } + + // If we have still some data buffered this data must be flush before + // mOutput.OnSocketReady(NS_OK) is called in + // nsSocketTransport::OnSocketReady, partially to keep socket status + // event in order. + mFastOpenLayerHasBufferedData = TCPFastOpenGetCurrentBufferSize(fd); + + MOZ_ASSERT((mFastOpenStatus == TFO_NOT_TRIED) || + (mFastOpenStatus == TFO_DISABLED) || + (mFastOpenStatus == TFO_DATA_SENT) || + (mFastOpenStatus == TFO_TRIED)); + mFastOpenCallback->SetFastOpenStatus(mFastOpenStatus); + SOCKET_LOG( + ("called StartFastOpen - code=%d; fastOpen is %s " + "supported.\n", + code, fastOpenNotSupported ? "not" : "")); + SOCKET_LOG(("TFO status %d\n", mFastOpenStatus)); + + if (fastOpenNotSupported) { + // When TCP_FastOpen is turned off on the local host + // SendTo will return PR_NOT_TCP_SOCKET_ERROR. This is only + // on Linux. + // If a windows version does not support Fast Open, the return value + // will be PR_NOT_IMPLEMENTED_ERROR. This is only for windows 10 + // versions older than version 1607, because we do not have subverion + // to check, we need to call PR_SendTo to check if it is supported. + mFastOpenCallback->FastOpenNotSupported(); + // FastOpenNotSupported will set Fast Open as not supported globally. + // For this connection we will pretend that we still use fast open, + // because of the fallback mechanism in case we need to restart the + // attached transaction. + connectCalled = true; + } + } else { + mFastOpenCallback = nullptr; + } + + if (gSocketTransportService->IsTelemetryEnabledAndNotSleepPhase() && + connectStarted && connectCalled) { + SendPRBlockingTelemetry( + connectStarted, Telemetry::PRCONNECT_BLOCKING_TIME_NORMAL, + Telemetry::PRCONNECT_BLOCKING_TIME_SHUTDOWN, + Telemetry::PRCONNECT_BLOCKING_TIME_CONNECTIVITY_CHANGE, + Telemetry::PRCONNECT_BLOCKING_TIME_LINK_CHANGE, + Telemetry::PRCONNECT_BLOCKING_TIME_OFFLINE); + } + + if (status == PR_SUCCESS) { + // + // we are connected! + // + OnSocketConnected(); + } else { +#if defined(TEST_CONNECT_ERRORS) + code = RandomizeConnectError(code); +#endif + // + // If the PR_Connect(...) would block, then poll for a connection. + // + if ((PR_WOULD_BLOCK_ERROR == code) || (PR_IN_PROGRESS_ERROR == code)) + mPollFlags = (PR_POLL_EXCEPT | PR_POLL_WRITE); + // + // If the socket is already connected, then return success... + // + else if (PR_IS_CONNECTED_ERROR == code) { + // + // we are connected! + // + OnSocketConnected(); + + if (mSecInfo && !mProxyHost.IsEmpty() && proxyTransparent && usingSSL) { + // if the connection phase is finished, and the ssl layer has + // been pushed, and we were proxying (transparently; ie. nothing + // has to happen in the protocol layer above us), it's time for + // the ssl to start doing it's thing. + nsCOMPtr<nsISSLSocketControl> secCtrl = do_QueryInterface(mSecInfo); + if (secCtrl) { + SOCKET_LOG((" calling ProxyStartSSL()\n")); + secCtrl->ProxyStartSSL(); + } + // XXX what if we were forced to poll on the socket for a successful + // connection... wouldn't we need to call ProxyStartSSL after a call + // to PR_ConnectContinue indicates that we are connected? + // + // XXX this appears to be what the old socket transport did. why + // isn't this broken? + } + } + // + // A SOCKS request was rejected; get the actual error code from + // the OS error + // + else if (PR_UNKNOWN_ERROR == code && mProxyTransparent && + !mProxyHost.IsEmpty()) { + code = PR_GetOSError(); + rv = ErrorAccordingToNSPR(code); + } + // + // The connection was refused... + // + else { + if (gSocketTransportService->IsTelemetryEnabledAndNotSleepPhase() && + connectStarted && connectCalled) { + SendPRBlockingTelemetry( + connectStarted, Telemetry::PRCONNECT_FAIL_BLOCKING_TIME_NORMAL, + Telemetry::PRCONNECT_FAIL_BLOCKING_TIME_SHUTDOWN, + Telemetry::PRCONNECT_FAIL_BLOCKING_TIME_CONNECTIVITY_CHANGE, + Telemetry::PRCONNECT_FAIL_BLOCKING_TIME_LINK_CHANGE, + Telemetry::PRCONNECT_FAIL_BLOCKING_TIME_OFFLINE); + } + + rv = ErrorAccordingToNSPR(code); + if ((rv == NS_ERROR_CONNECTION_REFUSED) && !mProxyHost.IsEmpty()) + rv = NS_ERROR_PROXY_CONNECTION_REFUSED; + } + } + return rv; +} + +bool nsSocketTransport::RecoverFromError() { + NS_ASSERTION(NS_FAILED(mCondition), "there should be something wrong"); + + SOCKET_LOG( + ("nsSocketTransport::RecoverFromError [this=%p state=%x cond=%" PRIx32 + "]\n", + this, mState, static_cast<uint32_t>(mCondition))); + + if (mDoNotRetryToConnect) { + SOCKET_LOG( + ("nsSocketTransport::RecoverFromError do not retry because " + "mDoNotRetryToConnect is set [this=%p]\n", + this)); + return false; + } + +#if defined(XP_UNIX) + // Unix domain connections don't have multiple addresses to try, + // so the recovery techniques here don't apply. + if (mNetAddrIsSet && mNetAddr.raw.family == AF_LOCAL) return false; +#endif + + if ((mConnectionFlags & nsSocketTransport::USE_IP_HINT_ADDRESS) && + mCondition == NS_ERROR_UNKNOWN_HOST && + (mState == MSG_DNS_LOOKUP_COMPLETE || mState == MSG_ENSURE_CONNECT)) { + SOCKET_LOG((" try again without USE_IP_HINT_ADDRESS")); + mConnectionFlags &= ~nsSocketTransport::USE_IP_HINT_ADDRESS; + mState = STATE_CLOSED; + return NS_SUCCEEDED(PostEvent(MSG_ENSURE_CONNECT, NS_OK)); + } + + // can only recover from errors in these states + if (mState != STATE_RESOLVING && mState != STATE_CONNECTING) { + SOCKET_LOG((" not in a recoverable state")); + return false; + } + + nsresult rv; + + // OK to check this outside mLock + NS_ASSERTION(!mFDconnected, "socket should not be connected"); + + // all connection failures need to be reported to DNS so that the next + // time we will use a different address if available. + // Skip conditions that can be cause by TCP Fast Open. + if ((!mFDFastOpenInProgress || + ((mCondition != NS_ERROR_CONNECTION_REFUSED) && + (mCondition != NS_ERROR_NET_TIMEOUT) && + (mCondition != NS_BASE_STREAM_CLOSED) && + (mCondition != NS_ERROR_PROXY_CONNECTION_REFUSED))) && + mState == STATE_CONNECTING && mDNSRecord) { + mDNSRecord->ReportUnusable(SocketPort()); + } + +#if defined(_WIN64) && defined(WIN95) + // can only recover from these errors + if (mCondition != NS_ERROR_CONNECTION_REFUSED && + mCondition != NS_ERROR_PROXY_CONNECTION_REFUSED && + mCondition != NS_ERROR_NET_TIMEOUT && + mCondition != NS_ERROR_UNKNOWN_HOST && + mCondition != NS_ERROR_UNKNOWN_PROXY_HOST && + !(mFDFastOpenInProgress && (mCondition == NS_ERROR_FAILURE))) { + SOCKET_LOG((" not a recoverable error %" PRIx32, + static_cast<uint32_t>(mCondition))); + return false; + } +#else + if (mCondition != NS_ERROR_CONNECTION_REFUSED && + mCondition != NS_ERROR_PROXY_CONNECTION_REFUSED && + mCondition != NS_ERROR_NET_TIMEOUT && + mCondition != NS_ERROR_UNKNOWN_HOST && + mCondition != NS_ERROR_UNKNOWN_PROXY_HOST) { + SOCKET_LOG((" not a recoverable error %" PRIx32, + static_cast<uint32_t>(mCondition))); + return false; + } +#endif + + bool tryAgain = false; + if (mFDFastOpenInProgress && + ((mCondition == NS_ERROR_CONNECTION_REFUSED) || + (mCondition == NS_ERROR_NET_TIMEOUT) || +#if defined(_WIN64) && defined(WIN95) + // On Windows PR_ContinueConnect can return NS_ERROR_FAILURE. + // This will be fixed in bug 1386719 and this is just a temporary + // work around. + (mCondition == NS_ERROR_FAILURE) || +#endif + (mCondition == NS_ERROR_PROXY_CONNECTION_REFUSED))) { + // TCP Fast Open can be blocked by middle boxes so we will retry + // without it. + tryAgain = true; + // If we cancel the connection because backup socket was successfully + // connected, mFDFastOpenInProgress will be true but mFastOpenCallback + // will be nullptr. + if (mFastOpenCallback) { + mFastOpenCallback->SetFastOpenConnected(mCondition, true); + } + mFastOpenCallback = nullptr; + + } else { + // This is only needed for telemetry. + if (NS_SUCCEEDED(mFirstRetryError)) { + mFirstRetryError = mCondition; + } + if ((mState == STATE_CONNECTING) && mDNSRecord) { + if (mNetAddr.raw.family == AF_INET) { + if (mSocketTransportService->IsTelemetryEnabledAndNotSleepPhase()) { + Telemetry::Accumulate(Telemetry::IPV4_AND_IPV6_ADDRESS_CONNECTIVITY, + UNSUCCESSFUL_CONNECTING_TO_IPV4_ADDRESS); + } + } else if (mNetAddr.raw.family == AF_INET6) { + if (mSocketTransportService->IsTelemetryEnabledAndNotSleepPhase()) { + Telemetry::Accumulate(Telemetry::IPV4_AND_IPV6_ADDRESS_CONNECTIVITY, + UNSUCCESSFUL_CONNECTING_TO_IPV6_ADDRESS); + } + } + } + + if (mConnectionFlags & RETRY_WITH_DIFFERENT_IP_FAMILY && + mCondition == NS_ERROR_UNKNOWN_HOST && mState == STATE_RESOLVING && + !mProxyTransparentResolvesHost) { + SOCKET_LOG((" trying lookup again with opposite ip family\n")); + mConnectionFlags ^= (DISABLE_IPV6 | DISABLE_IPV4); + mConnectionFlags &= ~RETRY_WITH_DIFFERENT_IP_FAMILY; + // This will tell the consuming half-open to reset preference on the + // connection entry + mResetFamilyPreference = true; + tryAgain = true; + } + + // try next ip address only if past the resolver stage... + if (mState == STATE_CONNECTING && mDNSRecord) { + nsresult rv = mDNSRecord->GetNextAddr(SocketPort(), &mNetAddr); + mDNSRecord->IsTRR(&mResolvedByTRR); + if (NS_SUCCEEDED(rv)) { + SOCKET_LOG((" trying again with next ip address\n")); + tryAgain = true; + } else if (mConnectionFlags & RETRY_WITH_DIFFERENT_IP_FAMILY) { + SOCKET_LOG((" failed to connect, trying with opposite ip family\n")); + // Drop state to closed. This will trigger new round of DNS + // resolving bellow. + mState = STATE_CLOSED; + mConnectionFlags ^= (DISABLE_IPV6 | DISABLE_IPV4); + mConnectionFlags &= ~RETRY_WITH_DIFFERENT_IP_FAMILY; + // This will tell the consuming half-open to reset preference on the + // connection entry + mResetFamilyPreference = true; + tryAgain = true; + } else if (!(mConnectionFlags & DISABLE_TRR)) { + bool trrEnabled; + mDNSRecord->IsTRR(&trrEnabled); + + // Bug 1648147 - If the server responded with `0.0.0.0` or `::` then we + // should intentionally not fallback to regular DNS. + if (!StaticPrefs::network_trr_fallback_on_zero_response() && + ((mNetAddr.raw.family == AF_INET && mNetAddr.inet.ip == 0) || + (mNetAddr.raw.family == AF_INET6 && + mNetAddr.inet6.ip.u64[0] == 0 && + mNetAddr.inet6.ip.u64[1] == 0))) { + SOCKET_LOG((" TRR returned 0.0.0.0 and there are no other IPs")); + } else if (trrEnabled) { + uint32_t trrMode = 0; + mDNSRecord->GetEffectiveTRRMode(&trrMode); + // If current trr mode is trr only, we should not retry. + if (trrMode != 3) { + // Drop state to closed. This will trigger a new round of + // DNS resolving. Bypass the cache this time since the + // cached data came from TRR and failed already! + SOCKET_LOG((" failed to connect with TRR enabled, try w/o\n")); + mState = STATE_CLOSED; + mConnectionFlags |= DISABLE_TRR | BYPASS_CACHE | REFRESH_CACHE; + tryAgain = true; + } + } + } + } + } + + // prepare to try again. + if (tryAgain) { + uint32_t msg; + + if (mState == STATE_CONNECTING) { + mState = STATE_RESOLVING; + msg = MSG_DNS_LOOKUP_COMPLETE; + } else { + mState = STATE_CLOSED; + msg = MSG_ENSURE_CONNECT; + } + + rv = PostEvent(msg, NS_OK); + if (NS_FAILED(rv)) tryAgain = false; + } + + return tryAgain; +} + +// called on the socket thread only +void nsSocketTransport::OnMsgInputClosed(nsresult reason) { + SOCKET_LOG(("nsSocketTransport::OnMsgInputClosed [this=%p reason=%" PRIx32 + "]\n", + this, static_cast<uint32_t>(reason))); + + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + mInputClosed = true; + // check if event should affect entire transport + if (NS_FAILED(reason) && (reason != NS_BASE_STREAM_CLOSED)) + mCondition = reason; // XXX except if NS_FAILED(mCondition), right?? + else if (mOutputClosed) + mCondition = + NS_BASE_STREAM_CLOSED; // XXX except if NS_FAILED(mCondition), right?? + else { + if (mState == STATE_TRANSFERRING) mPollFlags &= ~PR_POLL_READ; + mInput.OnSocketReady(reason); + } +} + +// called on the socket thread only +void nsSocketTransport::OnMsgOutputClosed(nsresult reason) { + SOCKET_LOG(("nsSocketTransport::OnMsgOutputClosed [this=%p reason=%" PRIx32 + "]\n", + this, static_cast<uint32_t>(reason))); + + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + mOutputClosed = true; + // check if event should affect entire transport + if (NS_FAILED(reason) && (reason != NS_BASE_STREAM_CLOSED)) + mCondition = reason; // XXX except if NS_FAILED(mCondition), right?? + else if (mInputClosed) + mCondition = + NS_BASE_STREAM_CLOSED; // XXX except if NS_FAILED(mCondition), right?? + else { + if (mState == STATE_TRANSFERRING) mPollFlags &= ~PR_POLL_WRITE; + mOutput.OnSocketReady(reason); + } +} + +void nsSocketTransport::OnSocketConnected() { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + SOCKET_LOG((" advancing to STATE_TRANSFERRING\n")); + + mPollFlags = (PR_POLL_READ | PR_POLL_WRITE | PR_POLL_EXCEPT); + mState = STATE_TRANSFERRING; + + // Set the m*AddrIsSet flags only when state has reached TRANSFERRING + // because we need to make sure its value does not change due to failover + mNetAddrIsSet = true; + + if (mFDFastOpenInProgress && mFastOpenCallback) { + // mFastOpenCallback can be null when for example h2 is negotiated on + // another connection to the same host and all connections are + // abandoned. + mFastOpenCallback->SetFastOpenConnected(NS_OK, false); + } + mFastOpenCallback = nullptr; + + // assign mFD (must do this within the transport lock), but take care not + // to trample over mFDref if mFD is already set. + { + MutexAutoLock lock(mLock); + NS_ASSERTION(mFD.IsInitialized(), "no socket"); + NS_ASSERTION(mFDref == 1, "wrong socket ref count"); + SetSocketName(mFD); + mFDconnected = true; + mFDFastOpenInProgress = false; + mPollTimeout = mTimeouts[TIMEOUT_READ_WRITE]; + } + + // Ensure keepalive is configured correctly if previously enabled. + if (mKeepaliveEnabled) { + nsresult rv = SetKeepaliveEnabledInternal(true); + if (NS_WARN_IF(NS_FAILED(rv))) { + SOCKET_LOG((" SetKeepaliveEnabledInternal failed rv[0x%" PRIx32 "]", + static_cast<uint32_t>(rv))); + } + } + + SendStatus(NS_NET_STATUS_CONNECTED_TO); +} + +void nsSocketTransport::SetSocketName(PRFileDesc* fd) { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + if (mSelfAddrIsSet) { + return; + } + + PRNetAddr prAddr; + memset(&prAddr, 0, sizeof(prAddr)); + if (PR_GetSockName(fd, &prAddr) == PR_SUCCESS) { + PRNetAddrToNetAddr(&prAddr, &mSelfAddr); + mSelfAddrIsSet = true; + } +} + +PRFileDesc* nsSocketTransport::GetFD_Locked() { + mLock.AssertCurrentThreadOwns(); + + // mFD is not available to the streams while disconnected. + if (!mFDconnected) return nullptr; + + if (mFD.IsInitialized()) mFDref++; + + return mFD; +} + +PRFileDesc* nsSocketTransport::GetFD_LockedAlsoDuringFastOpen() { + mLock.AssertCurrentThreadOwns(); + + // mFD is not available to the streams while disconnected. + if (!mFDconnected && !mFDFastOpenInProgress) { + return nullptr; + } + + if (mFD.IsInitialized()) { + mFDref++; + } + + return mFD; +} + +bool nsSocketTransport::FastOpenInProgress() { + mLock.AssertCurrentThreadOwns(); + return mFDFastOpenInProgress; +} + +class ThunkPRClose : public Runnable { + public: + explicit ThunkPRClose(PRFileDesc* fd) + : Runnable("net::ThunkPRClose"), mFD(fd) {} + + NS_IMETHOD Run() override { + nsSocketTransport::CloseSocket( + mFD, gSocketTransportService->IsTelemetryEnabledAndNotSleepPhase()); + return NS_OK; + } + + private: + PRFileDesc* mFD; +}; + +void STS_PRCloseOnSocketTransport(PRFileDesc* fd, bool lingerPolarity, + int16_t lingerTimeout) { + if (gSocketTransportService) { + // Can't PR_Close() a socket off STS thread. Thunk it to STS to die + gSocketTransportService->Dispatch(new ThunkPRClose(fd), NS_DISPATCH_NORMAL); + } else { + // something horrible has happened + NS_ASSERTION(gSocketTransportService, "No STS service"); + } +} + +void nsSocketTransport::ReleaseFD_Locked(PRFileDesc* fd) { + mLock.AssertCurrentThreadOwns(); + + NS_ASSERTION(mFD == fd, "wrong fd"); + + if (--mFDref == 0) { + if (gIOService->IsNetTearingDown() && + ((PR_IntervalNow() - gIOService->NetTearingDownStarted()) > + gSocketTransportService->MaxTimeForPrClosePref())) { + // If shutdown last to long, let the socket leak and do not close it. + SOCKET_LOG(("Intentional leak")); + } else { + if (mLingerPolarity || mLingerTimeout) { + PRSocketOptionData socket_linger; + socket_linger.option = PR_SockOpt_Linger; + socket_linger.value.linger.polarity = mLingerPolarity; + socket_linger.value.linger.linger = mLingerTimeout; + PR_SetSocketOption(mFD, &socket_linger); + } + if (OnSocketThread()) { + SOCKET_LOG(("nsSocketTransport: calling PR_Close [this=%p]\n", this)); + CloseSocket( + mFD, mSocketTransportService->IsTelemetryEnabledAndNotSleepPhase()); + } else { + // Can't PR_Close() a socket off STS thread. Thunk it to STS to die + STS_PRCloseOnSocketTransport(mFD, mLingerPolarity, mLingerTimeout); + } + } + mFD = nullptr; + } +} + +//----------------------------------------------------------------------------- +// socket event handler impl + +void nsSocketTransport::OnSocketEvent(uint32_t type, nsresult status, + nsISupports* param) { + SOCKET_LOG( + ("nsSocketTransport::OnSocketEvent [this=%p type=%u status=%" PRIx32 + " param=%p]\n", + this, type, static_cast<uint32_t>(status), param)); + + if (NS_FAILED(mCondition)) { + // block event since we're apparently already dead. + SOCKET_LOG((" blocking event [condition=%" PRIx32 "]\n", + static_cast<uint32_t>(mCondition))); + // + // notify input/output streams in case either has a pending notify. + // + mInput.OnSocketReady(mCondition); + mOutput.OnSocketReady(mCondition); + return; + } + + switch (type) { + case MSG_ENSURE_CONNECT: + SOCKET_LOG((" MSG_ENSURE_CONNECT\n")); + + // Apply port remapping here so that we do it on the socket thread and + // before we process the resolved DNS name or create the socket the first + // time. + if (!mPortRemappingApplied) { + mPortRemappingApplied = true; + + mSocketTransportService->ApplyPortRemap(&mPort); + mSocketTransportService->ApplyPortRemap(&mOriginPort); + } + + // + // ensure that we have created a socket, attached it, and have a + // connection. + // + if (mState == STATE_CLOSED) { + // Unix domain sockets are ready to connect; mNetAddr is all we + // need. Internet address families require a DNS lookup (or possibly + // several) before we can connect. +#if defined(XP_UNIX) + if (mNetAddrIsSet && mNetAddr.raw.family == AF_LOCAL) + mCondition = InitiateSocket(); + else +#endif + mCondition = ResolveHost(); + + } else { + SOCKET_LOG((" ignoring redundant event\n")); + } + break; + + case MSG_DNS_LOOKUP_COMPLETE: + if (mDNSRequest) { // only send this if we actually resolved anything + SendStatus(NS_NET_STATUS_RESOLVED_HOST); + } + + SOCKET_LOG((" MSG_DNS_LOOKUP_COMPLETE\n")); + mDNSRequest = nullptr; + + if (mDNSRecord) { + mDNSRecord->GetNextAddr(SocketPort(), &mNetAddr); + mDNSRecord->IsTRR(&mResolvedByTRR); + } + // status contains DNS lookup status + if (NS_FAILED(status)) { + // When using a HTTP proxy, NS_ERROR_UNKNOWN_HOST means the HTTP + // proxy host is not found, so we fixup the error code. + // For SOCKS proxies (mProxyTransparent == true), the socket + // transport resolves the real host here, so there's no fixup + // (see bug 226943). + if ((status == NS_ERROR_UNKNOWN_HOST) && !mProxyTransparent && + !mProxyHost.IsEmpty()) + mCondition = NS_ERROR_UNKNOWN_PROXY_HOST; + else + mCondition = status; + } else if (mState == STATE_RESOLVING) { + mCondition = InitiateSocket(); + } + break; + + case MSG_RETRY_INIT_SOCKET: + mCondition = InitiateSocket(); + break; + + case MSG_INPUT_CLOSED: + SOCKET_LOG((" MSG_INPUT_CLOSED\n")); + OnMsgInputClosed(status); + break; + + case MSG_INPUT_PENDING: + SOCKET_LOG((" MSG_INPUT_PENDING\n")); + OnMsgInputPending(); + break; + + case MSG_OUTPUT_CLOSED: + SOCKET_LOG((" MSG_OUTPUT_CLOSED\n")); + OnMsgOutputClosed(status); + break; + + case MSG_OUTPUT_PENDING: + SOCKET_LOG((" MSG_OUTPUT_PENDING\n")); + OnMsgOutputPending(); + break; + case MSG_TIMEOUT_CHANGED: + SOCKET_LOG((" MSG_TIMEOUT_CHANGED\n")); + { + MutexAutoLock lock(mLock); + mPollTimeout = + mTimeouts[(mState == STATE_TRANSFERRING) ? TIMEOUT_READ_WRITE + : TIMEOUT_CONNECT]; + } + break; + default: + SOCKET_LOG((" unhandled event!\n")); + } + + if (NS_FAILED(mCondition)) { + SOCKET_LOG((" after event [this=%p cond=%" PRIx32 "]\n", this, + static_cast<uint32_t>(mCondition))); + if (!mAttached) // need to process this error ourselves... + OnSocketDetached(nullptr); + } else if (mPollFlags == PR_POLL_EXCEPT) + mPollFlags = 0; // make idle +} + +//----------------------------------------------------------------------------- +// socket handler impl + +void nsSocketTransport::OnSocketReady(PRFileDesc* fd, int16_t outFlags) { + SOCKET_LOG1(("nsSocketTransport::OnSocketReady [this=%p outFlags=%hd]\n", + this, outFlags)); + + if (outFlags == -1) { + SOCKET_LOG(("socket timeout expired\n")); + mCondition = NS_ERROR_NET_TIMEOUT; + return; + } + + if ((mState == STATE_TRANSFERRING) && mFastOpenLayerHasBufferedData) { + // We have some data buffered in TCPFastOpenLayer. We will flush them + // first. We need to do this first before calling OnSocketReady below + // so that the socket status events are kept in the correct order. + mFastOpenLayerHasBufferedData = TCPFastOpenFlushBuffer(fd); + if (mFastOpenLayerHasBufferedData) { + return; + } + SendStatus(NS_NET_STATUS_SENDING_TO); + + // If we are done sending the buffered data continue with the normal + // path. + // In case of an error, TCPFastOpenFlushBuffer will return false and + // the normal code path will pick up the error. + mFastOpenLayerHasBufferedData = false; + } + + if (mState == STATE_TRANSFERRING) { + // if waiting to write and socket is writable or hit an exception. + if ((mPollFlags & PR_POLL_WRITE) && (outFlags & ~PR_POLL_READ)) { + // assume that we won't need to poll any longer (the stream will + // request that we poll again if it is still pending). + mPollFlags &= ~PR_POLL_WRITE; + mOutput.OnSocketReady(NS_OK); + } + // if waiting to read and socket is readable or hit an exception. + if ((mPollFlags & PR_POLL_READ) && (outFlags & ~PR_POLL_WRITE)) { + // assume that we won't need to poll any longer (the stream will + // request that we poll again if it is still pending). + mPollFlags &= ~PR_POLL_READ; + mInput.OnSocketReady(NS_OK); + } + // Update poll timeout in case it was changed + { + MutexAutoLock lock(mLock); + mPollTimeout = mTimeouts[TIMEOUT_READ_WRITE]; + } + } else if ((mState == STATE_CONNECTING) && !gIOService->IsNetTearingDown()) { + // We do not need to do PR_ConnectContinue when we are already + // shutting down. + + // We use PRIntervalTime here because we need + // nsIOService::LastOfflineStateChange time and + // nsIOService::LastConectivityChange time to be atomic. + PRIntervalTime connectStarted = 0; + if (gSocketTransportService->IsTelemetryEnabledAndNotSleepPhase()) { + connectStarted = PR_IntervalNow(); + } + + PRStatus status = PR_ConnectContinue(fd, outFlags); + +#if defined(_WIN64) && defined(WIN95) +# ifndef TCP_FASTOPEN +# define TCP_FASTOPEN 15 +# endif + + if (mFDFastOpenInProgress && mFastOpenCallback && + (mFastOpenStatus == TFO_DATA_SENT)) { + PROsfd osfd = PR_FileDesc2NativeHandle(fd); + BOOL option = 0; + int len = sizeof(option); + PRInt32 rv = getsockopt((SOCKET)osfd, IPPROTO_TCP, TCP_FASTOPEN, + (char*)&option, &len); + if (!rv && !option) { + // On error, I will let the normal necko paths pickup the error. + mFastOpenCallback->SetFastOpenStatus(TFO_DATA_COOKIE_NOT_ACCEPTED); + } + } +#endif + + if (gSocketTransportService->IsTelemetryEnabledAndNotSleepPhase() && + connectStarted) { + SendPRBlockingTelemetry( + connectStarted, Telemetry::PRCONNECTCONTINUE_BLOCKING_TIME_NORMAL, + Telemetry::PRCONNECTCONTINUE_BLOCKING_TIME_SHUTDOWN, + Telemetry::PRCONNECTCONTINUE_BLOCKING_TIME_CONNECTIVITY_CHANGE, + Telemetry::PRCONNECTCONTINUE_BLOCKING_TIME_LINK_CHANGE, + Telemetry::PRCONNECTCONTINUE_BLOCKING_TIME_OFFLINE); + } + + if (status == PR_SUCCESS) { + // + // we are connected! + // + OnSocketConnected(); + + if (mNetAddr.raw.family == AF_INET) { + if (mSocketTransportService->IsTelemetryEnabledAndNotSleepPhase()) { + Telemetry::Accumulate(Telemetry::IPV4_AND_IPV6_ADDRESS_CONNECTIVITY, + SUCCESSFUL_CONNECTING_TO_IPV4_ADDRESS); + } + } else if (mNetAddr.raw.family == AF_INET6) { + if (mSocketTransportService->IsTelemetryEnabledAndNotSleepPhase()) { + Telemetry::Accumulate(Telemetry::IPV4_AND_IPV6_ADDRESS_CONNECTIVITY, + SUCCESSFUL_CONNECTING_TO_IPV6_ADDRESS); + } + } + } else { + PRErrorCode code = PR_GetError(); +#if defined(TEST_CONNECT_ERRORS) + code = RandomizeConnectError(code); +#endif + // + // If the connect is still not ready, then continue polling... + // + if ((PR_WOULD_BLOCK_ERROR == code) || (PR_IN_PROGRESS_ERROR == code)) { + // Set up the select flags for connect... + mPollFlags = (PR_POLL_EXCEPT | PR_POLL_WRITE); + // Update poll timeout in case it was changed + { + MutexAutoLock lock(mLock); + mPollTimeout = mTimeouts[TIMEOUT_CONNECT]; + } + } + // + // The SOCKS proxy rejected our request. Find out why. + // + else if (PR_UNKNOWN_ERROR == code && mProxyTransparent && + !mProxyHost.IsEmpty()) { + code = PR_GetOSError(); + mCondition = ErrorAccordingToNSPR(code); + } else { + // + // else, the connection failed... + // + mCondition = ErrorAccordingToNSPR(code); + if ((mCondition == NS_ERROR_CONNECTION_REFUSED) && + !mProxyHost.IsEmpty()) + mCondition = NS_ERROR_PROXY_CONNECTION_REFUSED; + SOCKET_LOG((" connection failed! [reason=%" PRIx32 "]\n", + static_cast<uint32_t>(mCondition))); + } + } + } else if ((mState == STATE_CONNECTING) && gIOService->IsNetTearingDown()) { + // We do not need to do PR_ConnectContinue when we are already + // shutting down. + SOCKET_LOG( + ("We are in shutdown so skip PR_ConnectContinue and set " + "and error.\n")); + mCondition = NS_ERROR_ABORT; + } else { + NS_ERROR("unexpected socket state"); + mCondition = NS_ERROR_UNEXPECTED; + } + + if (mPollFlags == PR_POLL_EXCEPT) mPollFlags = 0; // make idle +} + +// called on the socket thread only +void nsSocketTransport::OnSocketDetached(PRFileDesc* fd) { + SOCKET_LOG(("nsSocketTransport::OnSocketDetached [this=%p cond=%" PRIx32 + "]\n", + this, static_cast<uint32_t>(mCondition))); + + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + mAttached = false; + + // if we didn't initiate this detach, then be sure to pass an error + // condition up to our consumers. (e.g., STS is shutting down.) + if (NS_SUCCEEDED(mCondition)) { + if (gIOService->IsOffline()) { + mCondition = NS_ERROR_OFFLINE; + } else { + mCondition = NS_ERROR_ABORT; + } + } + + mFastOpenLayerHasBufferedData = false; + + // If we are not shutting down try again. + if (!gIOService->IsNetTearingDown() && RecoverFromError()) + mCondition = NS_OK; + else { + mState = STATE_CLOSED; + + // The error can happened before we start fast open. In that case do not + // call mFastOpenCallback->SetFastOpenConnected; If error happends during + // fast open, inform the halfOpenSocket. + // If we cancel the connection because backup socket was successfully + // connected, mFDFastOpenInProgress will be true but mFastOpenCallback + // will be nullptr. + if (mFDFastOpenInProgress && mFastOpenCallback) { + mFastOpenCallback->SetFastOpenConnected(mCondition, false); + } + mFastOpenCallback = nullptr; + + // make sure there isn't any pending DNS request + if (mDNSRequest) { + mDNSRequest->Cancel(NS_ERROR_ABORT); + mDNSRequest = nullptr; + } + + // + // notify input/output streams + // + mInput.OnSocketReady(mCondition); + mOutput.OnSocketReady(mCondition); + } + + // If FastOpen has been used (mFDFastOpenInProgress==true), + // mFastOpenCallback must be nullptr now. We decided to recover from + // error like NET_TIMEOUT, CONNECTION_REFUSED or we have called + // SetFastOpenConnected(mCondition) in this function a couple of lines + // above. + // If FastOpen has not been used (mFDFastOpenInProgress==false) it can be + // that mFastOpenCallback is no null, this is the case when we recover from + // errors like UKNOWN_HOST in which case socket was not been connected yet + // and mFastOpenCallback-StartFastOpen was not be called yet (but we can + // still call it in the next try). + MOZ_ASSERT(!(mFDFastOpenInProgress && mFastOpenCallback)); + + // break any potential reference cycle between the security info object + // and ourselves by resetting its notification callbacks object. see + // bug 285991 for details. + nsCOMPtr<nsISSLSocketControl> secCtrl = do_QueryInterface(mSecInfo); + if (secCtrl) secCtrl->SetNotificationCallbacks(nullptr); + + // finally, release our reference to the socket (must do this within + // the transport lock) possibly closing the socket. Also release our + // listeners to break potential refcount cycles. + + // We should be careful not to release mEventSink and mCallbacks while + // we're locked, because releasing it might require acquiring the lock + // again, so we just null out mEventSink and mCallbacks while we're + // holding the lock, and let the stack based objects' destuctors take + // care of destroying it if needed. + nsCOMPtr<nsIInterfaceRequestor> ourCallbacks; + nsCOMPtr<nsITransportEventSink> ourEventSink; + { + MutexAutoLock lock(mLock); + if (mFD.IsInitialized()) { + ReleaseFD_Locked(mFD); + // flag mFD as unusable; this prevents other consumers from + // acquiring a reference to mFD. + mFDconnected = false; + mFDFastOpenInProgress = false; + } + + // We must release mCallbacks and mEventSink to avoid memory leak + // but only when RecoverFromError() above failed. Otherwise we lose + // link with UI and security callbacks on next connection attempt + // round. That would lead e.g. to a broken certificate exception page. + if (NS_FAILED(mCondition)) { + mCallbacks.swap(ourCallbacks); + mEventSink.swap(ourEventSink); + } + } +} + +void nsSocketTransport::IsLocal(bool* aIsLocal) { + { + MutexAutoLock lock(mLock); + +#if defined(XP_UNIX) + // Unix-domain sockets are always local. + if (mNetAddr.raw.family == PR_AF_LOCAL) { + *aIsLocal = true; + return; + } +#endif + + *aIsLocal = mNetAddr.IsLoopbackAddr(); + } +} + +//----------------------------------------------------------------------------- +// xpcom api + +NS_IMPL_ISUPPORTS(nsSocketTransport, nsISocketTransport, nsITransport, + nsIDNSListener, nsIClassInfo, nsIInterfaceRequestor) +NS_IMPL_CI_INTERFACE_GETTER(nsSocketTransport, nsISocketTransport, nsITransport, + nsIDNSListener, nsIInterfaceRequestor) + +NS_IMETHODIMP +nsSocketTransport::OpenInputStream(uint32_t flags, uint32_t segsize, + uint32_t segcount, nsIInputStream** result) { + SOCKET_LOG( + ("nsSocketTransport::OpenInputStream [this=%p flags=%x]\n", this, flags)); + + NS_ENSURE_TRUE(!mInput.IsReferenced(), NS_ERROR_UNEXPECTED); + + nsresult rv; + nsCOMPtr<nsIAsyncInputStream> pipeIn; + + if (!(flags & OPEN_UNBUFFERED) || (flags & OPEN_BLOCKING)) { + // XXX if the caller wants blocking, then the caller also gets buffered! + // bool openBuffered = !(flags & OPEN_UNBUFFERED); + bool openBlocking = (flags & OPEN_BLOCKING); + + net_ResolveSegmentParams(segsize, segcount); + + // create a pipe + nsCOMPtr<nsIAsyncOutputStream> pipeOut; + rv = NS_NewPipe2(getter_AddRefs(pipeIn), getter_AddRefs(pipeOut), + !openBlocking, true, segsize, segcount); + if (NS_FAILED(rv)) return rv; + + // async copy from socket to pipe + rv = NS_AsyncCopy(&mInput, pipeOut, mSocketTransportService, + NS_ASYNCCOPY_VIA_WRITESEGMENTS, segsize); + if (NS_FAILED(rv)) return rv; + + *result = pipeIn; + } else + *result = &mInput; + + // flag input stream as open + mInputClosed = false; + + rv = PostEvent(MSG_ENSURE_CONNECT); + if (NS_FAILED(rv)) return rv; + + NS_ADDREF(*result); + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::OpenOutputStream(uint32_t flags, uint32_t segsize, + uint32_t segcount, + nsIOutputStream** result) { + SOCKET_LOG(("nsSocketTransport::OpenOutputStream [this=%p flags=%x]\n", this, + flags)); + + NS_ENSURE_TRUE(!mOutput.IsReferenced(), NS_ERROR_UNEXPECTED); + + nsresult rv; + nsCOMPtr<nsIAsyncOutputStream> pipeOut; + if (!(flags & OPEN_UNBUFFERED) || (flags & OPEN_BLOCKING)) { + // XXX if the caller wants blocking, then the caller also gets buffered! + // bool openBuffered = !(flags & OPEN_UNBUFFERED); + bool openBlocking = (flags & OPEN_BLOCKING); + + net_ResolveSegmentParams(segsize, segcount); + + // create a pipe + nsCOMPtr<nsIAsyncInputStream> pipeIn; + rv = NS_NewPipe2(getter_AddRefs(pipeIn), getter_AddRefs(pipeOut), true, + !openBlocking, segsize, segcount); + if (NS_FAILED(rv)) return rv; + + // async copy from socket to pipe + rv = NS_AsyncCopy(pipeIn, &mOutput, mSocketTransportService, + NS_ASYNCCOPY_VIA_READSEGMENTS, segsize); + if (NS_FAILED(rv)) return rv; + + *result = pipeOut; + } else + *result = &mOutput; + + // flag output stream as open + mOutputClosed = false; + + rv = PostEvent(MSG_ENSURE_CONNECT); + if (NS_FAILED(rv)) return rv; + + NS_ADDREF(*result); + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::Close(nsresult reason) { + SOCKET_LOG(("nsSocketTransport::Close %p reason=%" PRIx32, this, + static_cast<uint32_t>(reason))); + + if (NS_SUCCEEDED(reason)) reason = NS_BASE_STREAM_CLOSED; + + mDoNotRetryToConnect = true; + + if (mFDFastOpenInProgress && mFastOpenCallback) { + mFastOpenCallback->SetFastOpenConnected(reason, false); + } + mFastOpenCallback = nullptr; + + mInput.CloseWithStatus(reason); + mOutput.CloseWithStatus(reason); + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::GetSecurityInfo(nsISupports** secinfo) { + MutexAutoLock lock(mLock); + NS_IF_ADDREF(*secinfo = mSecInfo); + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::GetSecurityCallbacks(nsIInterfaceRequestor** callbacks) { + MutexAutoLock lock(mLock); + NS_IF_ADDREF(*callbacks = mCallbacks); + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::SetSecurityCallbacks(nsIInterfaceRequestor* callbacks) { + nsCOMPtr<nsIInterfaceRequestor> threadsafeCallbacks; + NS_NewNotificationCallbacksAggregation(callbacks, nullptr, + GetCurrentEventTarget(), + getter_AddRefs(threadsafeCallbacks)); + + nsCOMPtr<nsISupports> secinfo; + { + MutexAutoLock lock(mLock); + mCallbacks = threadsafeCallbacks; + SOCKET_LOG(("Reset callbacks for secinfo=%p callbacks=%p\n", mSecInfo.get(), + mCallbacks.get())); + + secinfo = mSecInfo; + } + + // don't call into PSM while holding mLock!! + nsCOMPtr<nsISSLSocketControl> secCtrl(do_QueryInterface(secinfo)); + if (secCtrl) secCtrl->SetNotificationCallbacks(threadsafeCallbacks); + + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::SetEventSink(nsITransportEventSink* sink, + nsIEventTarget* target) { + nsCOMPtr<nsITransportEventSink> temp; + if (target) { + nsresult rv = + net_NewTransportEventSinkProxy(getter_AddRefs(temp), sink, target); + if (NS_FAILED(rv)) return rv; + sink = temp.get(); + } + + MutexAutoLock lock(mLock); + mEventSink = sink; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::IsAlive(bool* result) { + *result = false; + + // During Fast Open we need to return true here. + if (mFDFastOpenInProgress) { + *result = true; + return NS_OK; + } + + nsresult conditionWhileLocked = NS_OK; + PRFileDescAutoLock fd(this, false, &conditionWhileLocked); + if (NS_FAILED(conditionWhileLocked) || !fd.IsInitialized()) { + return NS_OK; + } + + // XXX do some idle-time based checks?? + + char c; + int32_t rval = PR_Recv(fd, &c, 1, PR_MSG_PEEK, 0); + + if ((rval > 0) || (rval < 0 && PR_GetError() == PR_WOULD_BLOCK_ERROR)) + *result = true; + + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::GetHost(nsACString& host) { + host = SocketHost(); + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::GetPort(int32_t* port) { + *port = (int32_t)SocketPort(); + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::GetScriptableOriginAttributes( + JSContext* aCx, JS::MutableHandle<JS::Value> aOriginAttributes) { + if (NS_WARN_IF(!ToJSValue(aCx, mOriginAttributes, aOriginAttributes))) { + return NS_ERROR_FAILURE; + } + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::SetScriptableOriginAttributes( + JSContext* aCx, JS::Handle<JS::Value> aOriginAttributes) { + MutexAutoLock lock(mLock); + NS_ENSURE_FALSE(mFD.IsInitialized(), NS_ERROR_FAILURE); + + OriginAttributes attrs; + if (!aOriginAttributes.isObject() || !attrs.Init(aCx, aOriginAttributes)) { + return NS_ERROR_INVALID_ARG; + } + + mOriginAttributes = attrs; + return NS_OK; +} + +nsresult nsSocketTransport::GetOriginAttributes( + OriginAttributes* aOriginAttributes) { + NS_ENSURE_ARG(aOriginAttributes); + *aOriginAttributes = mOriginAttributes; + return NS_OK; +} + +nsresult nsSocketTransport::SetOriginAttributes( + const OriginAttributes& aOriginAttributes) { + MutexAutoLock lock(mLock); + NS_ENSURE_FALSE(mFD.IsInitialized(), NS_ERROR_FAILURE); + + mOriginAttributes = aOriginAttributes; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::GetPeerAddr(NetAddr* addr) { + // once we are in the connected state, mNetAddr will not change. + // so if we can verify that we are in the connected state, then + // we can freely access mNetAddr from any thread without being + // inside a critical section. + + if (!mNetAddrIsSet) { + SOCKET_LOG( + ("nsSocketTransport::GetPeerAddr [this=%p state=%d] " + "NOT_AVAILABLE because not yet connected.", + this, mState)); + return NS_ERROR_NOT_AVAILABLE; + } + + memcpy(addr, &mNetAddr, sizeof(NetAddr)); + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::GetSelfAddr(NetAddr* addr) { + // once we are in the connected state, mSelfAddr will not change. + // so if we can verify that we are in the connected state, then + // we can freely access mSelfAddr from any thread without being + // inside a critical section. + + if (!mSelfAddrIsSet) { + SOCKET_LOG( + ("nsSocketTransport::GetSelfAddr [this=%p state=%d] " + "NOT_AVAILABLE because not yet connected.", + this, mState)); + return NS_ERROR_NOT_AVAILABLE; + } + + memcpy(addr, &mSelfAddr, sizeof(NetAddr)); + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::Bind(NetAddr* aLocalAddr) { + NS_ENSURE_ARG(aLocalAddr); + + MutexAutoLock lock(mLock); + if (mAttached) { + return NS_ERROR_FAILURE; + } + + mBindAddr = MakeUnique<NetAddr>(); + memcpy(mBindAddr.get(), aLocalAddr, sizeof(NetAddr)); + + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::GetScriptablePeerAddr(nsINetAddr** addr) { + NetAddr rawAddr; + + nsresult rv; + rv = GetPeerAddr(&rawAddr); + if (NS_FAILED(rv)) return rv; + + RefPtr<nsNetAddr> netaddr = new nsNetAddr(&rawAddr); + netaddr.forget(addr); + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::GetScriptableSelfAddr(nsINetAddr** addr) { + NetAddr rawAddr; + + nsresult rv; + rv = GetSelfAddr(&rawAddr); + if (NS_FAILED(rv)) return rv; + + RefPtr<nsNetAddr> netaddr = new nsNetAddr(&rawAddr); + netaddr.forget(addr); + + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::GetTimeout(uint32_t type, uint32_t* value) { + NS_ENSURE_ARG_MAX(type, nsISocketTransport::TIMEOUT_READ_WRITE); + MutexAutoLock lock(mLock); + *value = (uint32_t)mTimeouts[type]; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::SetTimeout(uint32_t type, uint32_t value) { + NS_ENSURE_ARG_MAX(type, nsISocketTransport::TIMEOUT_READ_WRITE); + + SOCKET_LOG(("nsSocketTransport::SetTimeout %p type=%u, value=%u", this, type, + value)); + + // truncate overly large timeout values. + { + MutexAutoLock lock(mLock); + mTimeouts[type] = (uint16_t)std::min<uint32_t>(value, UINT16_MAX); + } + PostEvent(MSG_TIMEOUT_CHANGED); + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::SetReuseAddrPort(bool reuseAddrPort) { + mReuseAddrPort = reuseAddrPort; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::SetLinger(bool aPolarity, int16_t aTimeout) { + MutexAutoLock lock(mLock); + + mLingerPolarity = aPolarity; + mLingerTimeout = aTimeout; + + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::SetQoSBits(uint8_t aQoSBits) { + // Don't do any checking here of bits. Why? Because as of RFC-4594 + // several different Class Selector and Assured Forwarding values + // have been defined, but that isn't to say more won't be added later. + // In that case, any checking would be an impediment to interoperating + // with newer QoS definitions. + + mQoSBits = aQoSBits; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::GetQoSBits(uint8_t* aQoSBits) { + *aQoSBits = mQoSBits; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::GetRecvBufferSize(uint32_t* aSize) { + PRFileDescAutoLock fd(this, false); + if (!fd.IsInitialized()) return NS_ERROR_NOT_CONNECTED; + + nsresult rv = NS_OK; + PRSocketOptionData opt; + opt.option = PR_SockOpt_RecvBufferSize; + if (PR_GetSocketOption(fd, &opt) == PR_SUCCESS) + *aSize = opt.value.recv_buffer_size; + else + rv = NS_ERROR_FAILURE; + + return rv; +} + +NS_IMETHODIMP +nsSocketTransport::GetSendBufferSize(uint32_t* aSize) { + PRFileDescAutoLock fd(this, false); + if (!fd.IsInitialized()) return NS_ERROR_NOT_CONNECTED; + + nsresult rv = NS_OK; + PRSocketOptionData opt; + opt.option = PR_SockOpt_SendBufferSize; + if (PR_GetSocketOption(fd, &opt) == PR_SUCCESS) + *aSize = opt.value.send_buffer_size; + else + rv = NS_ERROR_FAILURE; + + return rv; +} + +NS_IMETHODIMP +nsSocketTransport::SetRecvBufferSize(uint32_t aSize) { + PRFileDescAutoLock fd(this, false); + if (!fd.IsInitialized()) return NS_ERROR_NOT_CONNECTED; + + nsresult rv = NS_OK; + PRSocketOptionData opt; + opt.option = PR_SockOpt_RecvBufferSize; + opt.value.recv_buffer_size = aSize; + if (PR_SetSocketOption(fd, &opt) != PR_SUCCESS) rv = NS_ERROR_FAILURE; + + return rv; +} + +NS_IMETHODIMP +nsSocketTransport::SetSendBufferSize(uint32_t aSize) { + PRFileDescAutoLock fd(this, false); + if (!fd.IsInitialized()) return NS_ERROR_NOT_CONNECTED; + + nsresult rv = NS_OK; + PRSocketOptionData opt; + opt.option = PR_SockOpt_SendBufferSize; + opt.value.send_buffer_size = aSize; + if (PR_SetSocketOption(fd, &opt) != PR_SUCCESS) rv = NS_ERROR_FAILURE; + + return rv; +} + +NS_IMETHODIMP +nsSocketTransport::OnLookupComplete(nsICancelable* request, nsIDNSRecord* rec, + nsresult status) { + SOCKET_LOG(("nsSocketTransport::OnLookupComplete: this=%p status %" PRIx32 + ".", + this, static_cast<uint32_t>(status))); + + if (NS_SUCCEEDED(status)) { + mDNSRecord = do_QueryInterface(rec); + MOZ_ASSERT(mDNSRecord); + } + + // flag host lookup complete for the benefit of the ResolveHost method. + mResolving = false; + nsresult rv = PostEvent(MSG_DNS_LOOKUP_COMPLETE, status, nullptr); + + // if posting a message fails, then we should assume that the socket + // transport has been shutdown. this should never happen! if it does + // it means that the socket transport service was shutdown before the + // DNS service. + if (NS_FAILED(rv)) { + NS_WARNING("unable to post DNS lookup complete message"); + } + + return NS_OK; +} + +// nsIInterfaceRequestor +NS_IMETHODIMP +nsSocketTransport::GetInterface(const nsIID& iid, void** result) { + if (iid.Equals(NS_GET_IID(nsIDNSRecord)) || + iid.Equals(NS_GET_IID(nsIDNSAddrRecord))) { + return mDNSRecord ? mDNSRecord->QueryInterface(iid, result) + : NS_ERROR_NO_INTERFACE; + } + return this->QueryInterface(iid, result); +} + +NS_IMETHODIMP +nsSocketTransport::GetInterfaces(nsTArray<nsIID>& array) { + return NS_CI_INTERFACE_GETTER_NAME(nsSocketTransport)(array); +} + +NS_IMETHODIMP +nsSocketTransport::GetScriptableHelper(nsIXPCScriptable** _retval) { + *_retval = nullptr; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::GetContractID(nsACString& aContractID) { + aContractID.SetIsVoid(true); + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::GetClassDescription(nsACString& aClassDescription) { + aClassDescription.SetIsVoid(true); + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::GetClassID(nsCID** aClassID) { + *aClassID = nullptr; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::GetFlags(uint32_t* aFlags) { + *aFlags = nsIClassInfo::THREADSAFE; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::GetClassIDNoAlloc(nsCID* aClassIDNoAlloc) { + return NS_ERROR_NOT_AVAILABLE; +} + +NS_IMETHODIMP +nsSocketTransport::GetConnectionFlags(uint32_t* value) { + *value = mConnectionFlags; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::SetConnectionFlags(uint32_t value) { + SOCKET_LOG( + ("nsSocketTransport::SetConnectionFlags %p flags=%u", this, value)); + + mConnectionFlags = value; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::SetIsPrivate(bool aIsPrivate) { + mIsPrivate = aIsPrivate; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::GetTlsFlags(uint32_t* value) { + *value = mTlsFlags; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::SetTlsFlags(uint32_t value) { + mTlsFlags = value; + return NS_OK; +} + +void nsSocketTransport::OnKeepaliveEnabledPrefChange(bool aEnabled) { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + // The global pref toggles keepalive as a system feature; it only affects + // an individual socket if keepalive has been specifically enabled for it. + // So, ensure keepalive is configured correctly if previously enabled. + if (mKeepaliveEnabled) { + nsresult rv = SetKeepaliveEnabledInternal(aEnabled); + if (NS_WARN_IF(NS_FAILED(rv))) { + SOCKET_LOG((" SetKeepaliveEnabledInternal [%s] failed rv[0x%" PRIx32 "]", + aEnabled ? "enable" : "disable", static_cast<uint32_t>(rv))); + } + } +} + +nsresult nsSocketTransport::SetKeepaliveEnabledInternal(bool aEnable) { + MOZ_ASSERT(mKeepaliveIdleTimeS > 0 && mKeepaliveIdleTimeS <= kMaxTCPKeepIdle); + MOZ_ASSERT(mKeepaliveRetryIntervalS > 0 && + mKeepaliveRetryIntervalS <= kMaxTCPKeepIntvl); + MOZ_ASSERT(mKeepaliveProbeCount > 0 && + mKeepaliveProbeCount <= kMaxTCPKeepCount); + + PRFileDescAutoLock fd(this, true); + if (NS_WARN_IF(!fd.IsInitialized())) { + return NS_ERROR_NOT_INITIALIZED; + } + + // Only enable if keepalives are globally enabled, but ensure other + // options are set correctly on the fd. + bool enable = aEnable && mSocketTransportService->IsKeepaliveEnabled(); + nsresult rv = + fd.SetKeepaliveVals(enable, mKeepaliveIdleTimeS, mKeepaliveRetryIntervalS, + mKeepaliveProbeCount); + if (NS_WARN_IF(NS_FAILED(rv))) { + SOCKET_LOG((" SetKeepaliveVals failed rv[0x%" PRIx32 "]", + static_cast<uint32_t>(rv))); + return rv; + } + rv = fd.SetKeepaliveEnabled(enable); + if (NS_WARN_IF(NS_FAILED(rv))) { + SOCKET_LOG((" SetKeepaliveEnabled failed rv[0x%" PRIx32 "]", + static_cast<uint32_t>(rv))); + return rv; + } + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::GetKeepaliveEnabled(bool* aResult) { + MOZ_ASSERT(aResult); + + *aResult = mKeepaliveEnabled; + return NS_OK; +} + +nsresult nsSocketTransport::EnsureKeepaliveValsAreInitialized() { + nsresult rv = NS_OK; + int32_t val = -1; + if (mKeepaliveIdleTimeS == -1) { + rv = mSocketTransportService->GetKeepaliveIdleTime(&val); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + mKeepaliveIdleTimeS = val; + } + if (mKeepaliveRetryIntervalS == -1) { + rv = mSocketTransportService->GetKeepaliveRetryInterval(&val); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + mKeepaliveRetryIntervalS = val; + } + if (mKeepaliveProbeCount == -1) { + rv = mSocketTransportService->GetKeepaliveProbeCount(&val); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + mKeepaliveProbeCount = val; + } + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::SetKeepaliveEnabled(bool aEnable) { +#if defined(XP_WIN) || defined(XP_UNIX) || defined(XP_MACOSX) + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + if (aEnable == mKeepaliveEnabled) { + SOCKET_LOG(("nsSocketTransport::SetKeepaliveEnabled [%p] already %s.", this, + aEnable ? "enabled" : "disabled")); + return NS_OK; + } + + nsresult rv = NS_OK; + if (aEnable) { + rv = EnsureKeepaliveValsAreInitialized(); + if (NS_WARN_IF(NS_FAILED(rv))) { + SOCKET_LOG( + (" SetKeepaliveEnabled [%p] " + "error [0x%" PRIx32 "] initializing keepalive vals", + this, static_cast<uint32_t>(rv))); + return rv; + } + } + SOCKET_LOG( + ("nsSocketTransport::SetKeepaliveEnabled [%p] " + "%s, idle time[%ds] retry interval[%ds] packet count[%d]: " + "globally %s.", + this, aEnable ? "enabled" : "disabled", mKeepaliveIdleTimeS, + mKeepaliveRetryIntervalS, mKeepaliveProbeCount, + mSocketTransportService->IsKeepaliveEnabled() ? "enabled" : "disabled")); + + // Set mKeepaliveEnabled here so that state is maintained; it is possible + // that we're in between fds, e.g. the 1st IP address failed, so we're about + // to retry on a 2nd from the DNS record. + mKeepaliveEnabled = aEnable; + + rv = SetKeepaliveEnabledInternal(aEnable); + if (NS_WARN_IF(NS_FAILED(rv))) { + SOCKET_LOG((" SetKeepaliveEnabledInternal failed rv[0x%" PRIx32 "]", + static_cast<uint32_t>(rv))); + return rv; + } + + return NS_OK; +#else /* !(defined(XP_WIN) || defined(XP_UNIX) || defined(XP_MACOSX)) */ + SOCKET_LOG(("nsSocketTransport::SetKeepaliveEnabled unsupported platform")); + return NS_ERROR_NOT_IMPLEMENTED; +#endif +} + +NS_IMETHODIMP +nsSocketTransport::SetKeepaliveVals(int32_t aIdleTime, int32_t aRetryInterval) { +#if defined(XP_WIN) || defined(XP_UNIX) || defined(XP_MACOSX) + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + if (NS_WARN_IF(aIdleTime <= 0 || kMaxTCPKeepIdle < aIdleTime)) { + return NS_ERROR_INVALID_ARG; + } + if (NS_WARN_IF(aRetryInterval <= 0 || kMaxTCPKeepIntvl < aRetryInterval)) { + return NS_ERROR_INVALID_ARG; + } + + if (aIdleTime == mKeepaliveIdleTimeS && + aRetryInterval == mKeepaliveRetryIntervalS) { + SOCKET_LOG( + ("nsSocketTransport::SetKeepaliveVals [%p] idle time " + "already %ds and retry interval already %ds.", + this, mKeepaliveIdleTimeS, mKeepaliveRetryIntervalS)); + return NS_OK; + } + mKeepaliveIdleTimeS = aIdleTime; + mKeepaliveRetryIntervalS = aRetryInterval; + + nsresult rv = NS_OK; + if (mKeepaliveProbeCount == -1) { + int32_t val = -1; + nsresult rv = mSocketTransportService->GetKeepaliveProbeCount(&val); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + mKeepaliveProbeCount = val; + } + + SOCKET_LOG( + ("nsSocketTransport::SetKeepaliveVals [%p] " + "keepalive %s, idle time[%ds] retry interval[%ds] " + "packet count[%d]", + this, mKeepaliveEnabled ? "enabled" : "disabled", mKeepaliveIdleTimeS, + mKeepaliveRetryIntervalS, mKeepaliveProbeCount)); + + PRFileDescAutoLock fd(this, true); + if (NS_WARN_IF(!fd.IsInitialized())) { + return NS_ERROR_NULL_POINTER; + } + + rv = fd.SetKeepaliveVals(mKeepaliveEnabled, mKeepaliveIdleTimeS, + mKeepaliveRetryIntervalS, mKeepaliveProbeCount); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + return NS_OK; +#else + SOCKET_LOG(("nsSocketTransport::SetKeepaliveVals unsupported platform")); + return NS_ERROR_NOT_IMPLEMENTED; +#endif +} + +#ifdef ENABLE_SOCKET_TRACING + +# include <stdio.h> +# include <ctype.h> +# include "prenv.h" + +static void DumpBytesToFile(const char* path, const char* header, + const char* buf, int32_t n) { + FILE* fp = fopen(path, "a"); + + fprintf(fp, "\n%s [%d bytes]\n", header, n); + + const unsigned char* p; + while (n) { + p = (const unsigned char*)buf; + + int32_t i, row_max = std::min(16, n); + + for (i = 0; i < row_max; ++i) fprintf(fp, "%02x ", *p++); + for (i = row_max; i < 16; ++i) fprintf(fp, " "); + + p = (const unsigned char*)buf; + for (i = 0; i < row_max; ++i, ++p) { + if (isprint(*p)) + fprintf(fp, "%c", *p); + else + fprintf(fp, "."); + } + + fprintf(fp, "\n"); + buf += row_max; + n -= row_max; + } + + fprintf(fp, "\n"); + fclose(fp); +} + +void nsSocketTransport::TraceInBuf(const char* buf, int32_t n) { + char* val = PR_GetEnv("NECKO_SOCKET_TRACE_LOG"); + if (!val || !*val) return; + + nsAutoCString header; + header.AssignLiteral("Reading from: "); + header.Append(mHost); + header.Append(':'); + header.AppendInt(mPort); + + DumpBytesToFile(val, header.get(), buf, n); +} + +void nsSocketTransport::TraceOutBuf(const char* buf, int32_t n) { + char* val = PR_GetEnv("NECKO_SOCKET_TRACE_LOG"); + if (!val || !*val) return; + + nsAutoCString header; + header.AssignLiteral("Writing to: "); + header.Append(mHost); + header.Append(':'); + header.AppendInt(mPort); + + DumpBytesToFile(val, header.get(), buf, n); +} + +#endif + +static void LogNSPRError(const char* aPrefix, const void* aObjPtr) { +#if defined(DEBUG) + PRErrorCode errCode = PR_GetError(); + int errLen = PR_GetErrorTextLength(); + nsAutoCString errStr; + if (errLen > 0) { + errStr.SetLength(errLen); + PR_GetErrorText(errStr.BeginWriting()); + } + NS_WARNING( + nsPrintfCString("%s [%p] NSPR error[0x%x] %s.", + aPrefix ? aPrefix : "nsSocketTransport", aObjPtr, errCode, + errLen > 0 ? errStr.BeginReading() : "<no error text>") + .get()); +#endif +} + +nsresult nsSocketTransport::PRFileDescAutoLock::SetKeepaliveEnabled( + bool aEnable) { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + MOZ_ASSERT(!(aEnable && !gSocketTransportService->IsKeepaliveEnabled()), + "Cannot enable keepalive if global pref is disabled!"); + if (aEnable && !gSocketTransportService->IsKeepaliveEnabled()) { + return NS_ERROR_ILLEGAL_VALUE; + } + + PRSocketOptionData opt; + + opt.option = PR_SockOpt_Keepalive; + opt.value.keep_alive = aEnable; + PRStatus status = PR_SetSocketOption(mFd, &opt); + if (NS_WARN_IF(status != PR_SUCCESS)) { + LogNSPRError("nsSocketTransport::PRFileDescAutoLock::SetKeepaliveEnabled", + mSocketTransport); + return ErrorAccordingToNSPR(PR_GetError()); + } + return NS_OK; +} + +static void LogOSError(const char* aPrefix, const void* aObjPtr) { +#if defined(DEBUG) + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + +# ifdef XP_WIN + DWORD errCode = WSAGetLastError(); + LPVOID errMessage; + FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, errCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), + (LPTSTR)&errMessage, 0, NULL); +# else + int errCode = errno; + char* errMessage = strerror(errno); +# endif + NS_WARNING(nsPrintfCString("%s [%p] OS error[0x%x] %s", + aPrefix ? aPrefix : "nsSocketTransport", aObjPtr, + errCode, + errMessage ? errMessage : "<no error text>") + .get()); +# ifdef XP_WIN + LocalFree(errMessage); +# endif +#endif +} + +/* XXX PR_SetSockOpt does not support setting keepalive values, so native + * handles and platform specific apis (setsockopt, WSAIOCtl) are used in this + * file. Requires inclusion of NSPR private/pprio.h, and platform headers. + */ + +nsresult nsSocketTransport::PRFileDescAutoLock::SetKeepaliveVals( + bool aEnabled, int aIdleTime, int aRetryInterval, int aProbeCount) { +#if defined(XP_WIN) || defined(XP_UNIX) || defined(XP_MACOSX) + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + if (NS_WARN_IF(aIdleTime <= 0 || kMaxTCPKeepIdle < aIdleTime)) { + return NS_ERROR_INVALID_ARG; + } + if (NS_WARN_IF(aRetryInterval <= 0 || kMaxTCPKeepIntvl < aRetryInterval)) { + return NS_ERROR_INVALID_ARG; + } + if (NS_WARN_IF(aProbeCount <= 0 || kMaxTCPKeepCount < aProbeCount)) { + return NS_ERROR_INVALID_ARG; + } + + PROsfd sock = PR_FileDesc2NativeHandle(mFd); + if (NS_WARN_IF(sock == -1)) { + LogNSPRError("nsSocketTransport::PRFileDescAutoLock::SetKeepaliveVals", + mSocketTransport); + return ErrorAccordingToNSPR(PR_GetError()); + } +#endif + +#if defined(XP_WIN) + // Windows allows idle time and retry interval to be set; NOT ping count. + struct tcp_keepalive keepalive_vals = {(u_long)aEnabled, + // Windows uses msec. + (u_long)(aIdleTime * 1000UL), + (u_long)(aRetryInterval * 1000UL)}; + DWORD bytes_returned; + int err = + WSAIoctl(sock, SIO_KEEPALIVE_VALS, &keepalive_vals, + sizeof(keepalive_vals), NULL, 0, &bytes_returned, NULL, NULL); + if (NS_WARN_IF(err)) { + LogOSError("nsSocketTransport WSAIoctl failed", mSocketTransport); + return NS_ERROR_UNEXPECTED; + } + return NS_OK; + +#elif defined(XP_DARWIN) + // Darwin uses sec; only supports idle time being set. + int err = setsockopt(sock, IPPROTO_TCP, TCP_KEEPALIVE, &aIdleTime, + sizeof(aIdleTime)); + if (NS_WARN_IF(err)) { + LogOSError("nsSocketTransport Failed setting TCP_KEEPALIVE", + mSocketTransport); + return NS_ERROR_UNEXPECTED; + } + return NS_OK; + +#elif defined(XP_UNIX) + // Not all *nix OSes support the following setsockopt() options + // ... but we assume they are supported in the Android kernel; + // build errors will tell us if they are not. +# if defined(ANDROID) || defined(TCP_KEEPIDLE) + // Idle time until first keepalive probe; interval between ack'd probes; + // seconds. + int err = setsockopt(sock, IPPROTO_TCP, TCP_KEEPIDLE, &aIdleTime, + sizeof(aIdleTime)); + if (NS_WARN_IF(err)) { + LogOSError("nsSocketTransport Failed setting TCP_KEEPIDLE", + mSocketTransport); + return NS_ERROR_UNEXPECTED; + } + +# endif +# if defined(ANDROID) || defined(TCP_KEEPINTVL) + // Interval between unack'd keepalive probes; seconds. + err = setsockopt(sock, IPPROTO_TCP, TCP_KEEPINTVL, &aRetryInterval, + sizeof(aRetryInterval)); + if (NS_WARN_IF(err)) { + LogOSError("nsSocketTransport Failed setting TCP_KEEPINTVL", + mSocketTransport); + return NS_ERROR_UNEXPECTED; + } + +# endif +# if defined(ANDROID) || defined(TCP_KEEPCNT) + // Number of unack'd keepalive probes before connection times out. + err = setsockopt(sock, IPPROTO_TCP, TCP_KEEPCNT, &aProbeCount, + sizeof(aProbeCount)); + if (NS_WARN_IF(err)) { + LogOSError("nsSocketTransport Failed setting TCP_KEEPCNT", + mSocketTransport); + return NS_ERROR_UNEXPECTED; + } + +# endif + return NS_OK; +#else + MOZ_ASSERT(false, + "nsSocketTransport::PRFileDescAutoLock::SetKeepaliveVals " + "called on unsupported platform!"); + return NS_ERROR_UNEXPECTED; +#endif +} + +void nsSocketTransport::CloseSocket(PRFileDesc* aFd, bool aTelemetryEnabled) { +#if defined(XP_WIN) + AttachShutdownLayer(aFd); +#endif + + // We use PRIntervalTime here because we need + // nsIOService::LastOfflineStateChange time and + // nsIOService::LastConectivityChange time to be atomic. + PRIntervalTime closeStarted; + if (aTelemetryEnabled) { + closeStarted = PR_IntervalNow(); + } + + PR_Close(aFd); + + if (aTelemetryEnabled) { + SendPRBlockingTelemetry( + closeStarted, Telemetry::PRCLOSE_TCP_BLOCKING_TIME_NORMAL, + Telemetry::PRCLOSE_TCP_BLOCKING_TIME_SHUTDOWN, + Telemetry::PRCLOSE_TCP_BLOCKING_TIME_CONNECTIVITY_CHANGE, + Telemetry::PRCLOSE_TCP_BLOCKING_TIME_LINK_CHANGE, + Telemetry::PRCLOSE_TCP_BLOCKING_TIME_OFFLINE); + } +} + +void nsSocketTransport::SendPRBlockingTelemetry( + PRIntervalTime aStart, Telemetry::HistogramID aIDNormal, + Telemetry::HistogramID aIDShutdown, + Telemetry::HistogramID aIDConnectivityChange, + Telemetry::HistogramID aIDLinkChange, Telemetry::HistogramID aIDOffline) { + PRIntervalTime now = PR_IntervalNow(); + if (gIOService->IsNetTearingDown()) { + Telemetry::Accumulate(aIDShutdown, PR_IntervalToMilliseconds(now - aStart)); + + } else if (PR_IntervalToSeconds(now - gIOService->LastConnectivityChange()) < + 60) { + Telemetry::Accumulate(aIDConnectivityChange, + PR_IntervalToMilliseconds(now - aStart)); + } else if (PR_IntervalToSeconds(now - gIOService->LastNetworkLinkChange()) < + 60) { + Telemetry::Accumulate(aIDLinkChange, + PR_IntervalToMilliseconds(now - aStart)); + + } else if (PR_IntervalToSeconds(now - gIOService->LastOfflineStateChange()) < + 60) { + Telemetry::Accumulate(aIDOffline, PR_IntervalToMilliseconds(now - aStart)); + } else { + Telemetry::Accumulate(aIDNormal, PR_IntervalToMilliseconds(now - aStart)); + } +} + +NS_IMETHODIMP +nsSocketTransport::SetFastOpenCallback(TCPFastOpen* aFastOpen) { + mFastOpenCallback = aFastOpen; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::GetFirstRetryError(nsresult* aFirstRetryError) { + *aFirstRetryError = mFirstRetryError; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::GetResetIPFamilyPreference(bool* aReset) { + *aReset = mResetFamilyPreference; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::GetEchConfigUsed(bool* aEchConfigUsed) { + *aEchConfigUsed = mEchConfigUsed; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::SetEchConfig(const nsACString& aEchConfig) { + mEchConfig = aEchConfig; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransport::ResolvedByTRR(bool* aResolvedByTRR) { + *aResolvedByTRR = mResolvedByTRR; + return NS_OK; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/nsSocketTransport2.h b/netwerk/base/nsSocketTransport2.h new file mode 100644 index 0000000000..a3f38450eb --- /dev/null +++ b/netwerk/base/nsSocketTransport2.h @@ -0,0 +1,486 @@ +/* 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/. */ + +#ifndef nsSocketTransport2_h__ +#define nsSocketTransport2_h__ + +#ifdef DEBUG_darinf +# define ENABLE_SOCKET_TRACING +#endif + +#include "mozilla/Mutex.h" +#include "nsSocketTransportService2.h" +#include "nsString.h" +#include "nsCOMPtr.h" + +#include "nsIInterfaceRequestor.h" +#include "nsISocketTransport.h" +#include "nsIAsyncInputStream.h" +#include "nsIAsyncOutputStream.h" +#include "nsIDNSListener.h" +#include "nsIDNSRecord.h" +#include "nsIClassInfo.h" +#include "TCPFastOpen.h" +#include "mozilla/net/DNS.h" +#include "nsASocketHandler.h" +#include "mozilla/Telemetry.h" + +#include "prerror.h" +#include "ssl.h" + +class nsICancelable; +class nsIDNSRecord; +class nsIInterfaceRequestor; + +//----------------------------------------------------------------------------- + +// after this short interval, we will return to PR_Poll +#define NS_SOCKET_CONNECT_TIMEOUT PR_MillisecondsToInterval(20) + +//----------------------------------------------------------------------------- + +namespace mozilla { +namespace net { + +nsresult ErrorAccordingToNSPR(PRErrorCode errorCode); + +class nsSocketTransport; + +class nsSocketInputStream : public nsIAsyncInputStream { + public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_NSIINPUTSTREAM + NS_DECL_NSIASYNCINPUTSTREAM + + explicit nsSocketInputStream(nsSocketTransport*); + virtual ~nsSocketInputStream() = default; + + bool IsReferenced() { return mReaderRefCnt > 0; } + nsresult Condition() { return mCondition; } + uint64_t ByteCount() { return mByteCount; } + + // called by the socket transport on the socket thread... + void OnSocketReady(nsresult condition); + + private: + nsSocketTransport* mTransport; + ThreadSafeAutoRefCnt mReaderRefCnt; + + // access to these is protected by mTransport->mLock + nsresult mCondition; + nsCOMPtr<nsIInputStreamCallback> mCallback; + uint32_t mCallbackFlags; + uint64_t mByteCount; +}; + +//----------------------------------------------------------------------------- + +class nsSocketOutputStream : public nsIAsyncOutputStream { + public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_NSIOUTPUTSTREAM + NS_DECL_NSIASYNCOUTPUTSTREAM + + explicit nsSocketOutputStream(nsSocketTransport*); + virtual ~nsSocketOutputStream() = default; + + bool IsReferenced() { return mWriterRefCnt > 0; } + nsresult Condition() { return mCondition; } + uint64_t ByteCount() { return mByteCount; } + + // called by the socket transport on the socket thread... + void OnSocketReady(nsresult condition); + + private: + static nsresult WriteFromSegments(nsIInputStream*, void*, const char*, + uint32_t offset, uint32_t count, + uint32_t* countRead); + + nsSocketTransport* mTransport; + ThreadSafeAutoRefCnt mWriterRefCnt; + + // access to these is protected by mTransport->mLock + nsresult mCondition; + nsCOMPtr<nsIOutputStreamCallback> mCallback; + uint32_t mCallbackFlags; + uint64_t mByteCount; +}; + +//----------------------------------------------------------------------------- + +class nsSocketTransport final : public nsASocketHandler, + public nsISocketTransport, + public nsIDNSListener, + public nsIClassInfo, + public nsIInterfaceRequestor { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSITRANSPORT + NS_DECL_NSISOCKETTRANSPORT + NS_DECL_NSIDNSLISTENER + NS_DECL_NSICLASSINFO + NS_DECL_NSIINTERFACEREQUESTOR + + nsSocketTransport(); + + // this method instructs the socket transport to open a socket of the + // given type(s) to the given host or proxy. + nsresult Init(const nsTArray<nsCString>& socketTypes, const nsACString& host, + uint16_t port, const nsACString& hostRoute, uint16_t portRoute, + nsIProxyInfo* proxyInfo); + + // this method instructs the socket transport to use an already connected + // socket with the given address. + nsresult InitWithConnectedSocket(PRFileDesc* socketFD, const NetAddr* addr); + + // this method instructs the socket transport to use an already connected + // socket with the given address, and additionally supplies security info. + nsresult InitWithConnectedSocket(PRFileDesc* aSocketFD, const NetAddr* aAddr, + nsISupports* aSecInfo); + +#ifdef XP_UNIX + // This method instructs the socket transport to open a socket + // connected to the given Unix domain address. We can only create + // unlayered, simple, stream sockets. + nsresult InitWithFilename(const char* filename); + + // This method instructs the socket transport to open a socket + // connected to the given Unix domain address that includes abstract + // socket address. If using abstract socket address, first character of + // name parameter has to be \0. + // We can only create unlayered, simple, stream sockets. + nsresult InitWithName(const char* name, size_t len); +#endif + + // nsASocketHandler methods: + void OnSocketReady(PRFileDesc*, int16_t outFlags) override; + void OnSocketDetached(PRFileDesc*) override; + void IsLocal(bool* aIsLocal) override; + void OnKeepaliveEnabledPrefChange(bool aEnabled) final; + + // called when a socket event is handled + void OnSocketEvent(uint32_t type, nsresult status, nsISupports* param); + + uint64_t ByteCountReceived() override { return mInput.ByteCount(); } + uint64_t ByteCountSent() override { return mOutput.ByteCount(); } + static void CloseSocket(PRFileDesc* aFd, bool aTelemetryEnabled); + static void SendPRBlockingTelemetry( + PRIntervalTime aStart, Telemetry::HistogramID aIDNormal, + Telemetry::HistogramID aIDShutdown, + Telemetry::HistogramID aIDConnectivityChange, + Telemetry::HistogramID aIDLinkChange, Telemetry::HistogramID aIDOffline); + + protected: + virtual ~nsSocketTransport(); + + private: + // event types + enum { + MSG_ENSURE_CONNECT, + MSG_DNS_LOOKUP_COMPLETE, + MSG_RETRY_INIT_SOCKET, + MSG_TIMEOUT_CHANGED, + MSG_INPUT_CLOSED, + MSG_INPUT_PENDING, + MSG_OUTPUT_CLOSED, + MSG_OUTPUT_PENDING + }; + nsresult PostEvent(uint32_t type, nsresult status = NS_OK, + nsISupports* param = nullptr); + + enum { + STATE_CLOSED, + STATE_IDLE, + STATE_RESOLVING, + STATE_CONNECTING, + STATE_TRANSFERRING + }; + + // Safer way to get and automatically release PRFileDesc objects. + class MOZ_STACK_CLASS PRFileDescAutoLock { + public: + explicit PRFileDescAutoLock(nsSocketTransport* aSocketTransport, + bool aAlsoDuringFastOpen, + nsresult* aConditionWhileLocked = nullptr) + : mSocketTransport(aSocketTransport), mFd(nullptr) { + MOZ_ASSERT(aSocketTransport); + MutexAutoLock lock(mSocketTransport->mLock); + if (aConditionWhileLocked) { + *aConditionWhileLocked = mSocketTransport->mCondition; + if (NS_FAILED(mSocketTransport->mCondition)) { + return; + } + } + if (!aAlsoDuringFastOpen) { + mFd = mSocketTransport->GetFD_Locked(); + } else { + mFd = mSocketTransport->GetFD_LockedAlsoDuringFastOpen(); + } + } + ~PRFileDescAutoLock() { + MutexAutoLock lock(mSocketTransport->mLock); + if (mFd) { + mSocketTransport->ReleaseFD_Locked(mFd); + } + } + bool IsInitialized() { return mFd; } + operator PRFileDesc*() { return mFd; } + nsresult SetKeepaliveEnabled(bool aEnable); + nsresult SetKeepaliveVals(bool aEnabled, int aIdleTime, int aRetryInterval, + int aProbeCount); + + private: + operator PRFileDescAutoLock*() { return nullptr; } + + // Weak ptr to nsSocketTransport since this is a stack class only. + nsSocketTransport* mSocketTransport; + PRFileDesc* mFd; + }; + friend class PRFileDescAutoLock; + + class LockedPRFileDesc { + public: + explicit LockedPRFileDesc(nsSocketTransport* aSocketTransport) + : mSocketTransport(aSocketTransport), mFd(nullptr) { + MOZ_ASSERT(aSocketTransport); + } + ~LockedPRFileDesc() = default; + bool IsInitialized() { return mFd; } + LockedPRFileDesc& operator=(PRFileDesc* aFd) { + mSocketTransport->mLock.AssertCurrentThreadOwns(); + mFd = aFd; + return *this; + } + operator PRFileDesc*() { + if (mSocketTransport->mAttached) { + mSocketTransport->mLock.AssertCurrentThreadOwns(); + } + return mFd; + } + bool operator==(PRFileDesc* aFd) { + mSocketTransport->mLock.AssertCurrentThreadOwns(); + return mFd == aFd; + } + + private: + operator LockedPRFileDesc*() { return nullptr; } + // Weak ptr to nsSocketTransport since it owns this class. + nsSocketTransport* mSocketTransport; + PRFileDesc* mFd; + }; + friend class LockedPRFileDesc; + + //------------------------------------------------------------------------- + // these members are "set" at initialization time and are never modified + // afterwards. this allows them to be safely accessed from any thread. + //------------------------------------------------------------------------- + + // socket type info: + nsTArray<nsCString> mTypes; + nsCString mHost; + nsCString mProxyHost; + nsCString mOriginHost; + uint16_t mPort; + nsCOMPtr<nsIProxyInfo> mProxyInfo; + uint16_t mProxyPort; + uint16_t mOriginPort; + bool mProxyTransparent; + bool mProxyTransparentResolvesHost; + bool mHttpsProxy; + uint32_t mConnectionFlags; + // When we fail to connect using a prefered IP family, we tell the consumer to + // reset the IP family preference on the connection entry. + bool mResetFamilyPreference; + uint32_t mTlsFlags; + bool mReuseAddrPort; + + // The origin attributes are used to create sockets. The first party domain + // will eventually be used to isolate OCSP cache and is only non-empty when + // "privacy.firstparty.isolate" is enabled. Setting this is the only way to + // carry origin attributes down to NSPR layers which are final consumers. + // It must be set before the socket transport is built. + OriginAttributes mOriginAttributes; + + uint16_t SocketPort() { + return (!mProxyHost.IsEmpty() && !mProxyTransparent) ? mProxyPort : mPort; + } + const nsCString& SocketHost() { + return (!mProxyHost.IsEmpty() && !mProxyTransparent) ? mProxyHost : mHost; + } + + //------------------------------------------------------------------------- + // members accessible only on the socket transport thread: + // (the exception being initialization/shutdown time) + //------------------------------------------------------------------------- + + // socket state vars: + uint32_t mState; // STATE_??? flags + bool mAttached; + bool mInputClosed; + bool mOutputClosed; + + // this flag is used to determine if the results of a host lookup arrive + // recursively or not. this flag is not protected by any lock. + bool mResolving; + + nsCOMPtr<nsICancelable> mDNSRequest; + nsCOMPtr<nsIDNSAddrRecord> mDNSRecord; + + nsCString mEchConfig; + bool mEchConfigUsed = false; + bool mResolvedByTRR; + + // mNetAddr/mSelfAddr is valid from GetPeerAddr()/GetSelfAddr() once we have + // reached STATE_TRANSFERRING. It must not change after that. + void SetSocketName(PRFileDesc* fd); + NetAddr mNetAddr; + NetAddr mSelfAddr; // getsockname() + Atomic<bool, Relaxed> mNetAddrIsSet; + Atomic<bool, Relaxed> mSelfAddrIsSet; + + UniquePtr<NetAddr> mBindAddr; + + // socket methods (these can only be called on the socket thread): + + void SendStatus(nsresult status); + nsresult ResolveHost(); + nsresult BuildSocket(PRFileDesc*&, bool&, bool&); + nsresult InitiateSocket(); + bool RecoverFromError(); + + void OnMsgInputPending() { + if (mState == STATE_TRANSFERRING) + mPollFlags |= (PR_POLL_READ | PR_POLL_EXCEPT); + } + void OnMsgOutputPending() { + if (mState == STATE_TRANSFERRING) + mPollFlags |= (PR_POLL_WRITE | PR_POLL_EXCEPT); + } + void OnMsgInputClosed(nsresult reason); + void OnMsgOutputClosed(nsresult reason); + + // called when the socket is connected + void OnSocketConnected(); + + //------------------------------------------------------------------------- + // socket input/output objects. these may be accessed on any thread with + // the exception of some specific methods (XXX). + + Mutex mLock; // protects members in this section. + LockedPRFileDesc mFD; + nsrefcnt mFDref; // mFD is closed when mFDref goes to zero. + bool mFDconnected; // mFD is available to consumer when TRUE. + bool mFDFastOpenInProgress; // Fast Open is in progress, so + // socket available for some + // operations. + + // A delete protector reference to gSocketTransportService held for lifetime + // of 'this'. Sometimes used interchangably with gSocketTransportService due + // to scoping. + RefPtr<nsSocketTransportService> mSocketTransportService; + + nsCOMPtr<nsIInterfaceRequestor> mCallbacks; + nsCOMPtr<nsITransportEventSink> mEventSink; + nsCOMPtr<nsISupports> mSecInfo; + + nsSocketInputStream mInput; + nsSocketOutputStream mOutput; + + friend class nsSocketInputStream; + friend class nsSocketOutputStream; + + // socket timeouts are protected by mLock. + uint16_t mTimeouts[2]; + + // linger options to use when closing + bool mLingerPolarity; + int16_t mLingerTimeout; + + // QoS setting for socket + uint8_t mQoSBits; + + // + // mFD access methods: called with mLock held. + // + PRFileDesc* GetFD_Locked(); + PRFileDesc* GetFD_LockedAlsoDuringFastOpen(); + void ReleaseFD_Locked(PRFileDesc* fd); + bool FastOpenInProgress(); + + // + // stream state changes (called outside mLock): + // + void OnInputClosed(nsresult reason) { + // no need to post an event if called on the socket thread + if (OnSocketThread()) + OnMsgInputClosed(reason); + else + PostEvent(MSG_INPUT_CLOSED, reason); + } + void OnInputPending() { + // no need to post an event if called on the socket thread + if (OnSocketThread()) + OnMsgInputPending(); + else + PostEvent(MSG_INPUT_PENDING); + } + void OnOutputClosed(nsresult reason) { + // no need to post an event if called on the socket thread + if (OnSocketThread()) + OnMsgOutputClosed(reason); // XXX need to not be inside lock! + else + PostEvent(MSG_OUTPUT_CLOSED, reason); + } + void OnOutputPending() { + // no need to post an event if called on the socket thread + if (OnSocketThread()) + OnMsgOutputPending(); + else + PostEvent(MSG_OUTPUT_PENDING); + } + +#ifdef ENABLE_SOCKET_TRACING + void TraceInBuf(const char* buf, int32_t n); + void TraceOutBuf(const char* buf, int32_t n); +#endif + + // Reads prefs to get default keepalive config. + nsresult EnsureKeepaliveValsAreInitialized(); + + // Groups calls to fd.SetKeepaliveEnabled and fd.SetKeepaliveVals. + nsresult SetKeepaliveEnabledInternal(bool aEnable); + + // True if keepalive has been enabled by the socket owner. Note: Keepalive + // must also be enabled globally for it to be enabled in TCP. + bool mKeepaliveEnabled; + + // Keepalive config (support varies by platform). + int32_t mKeepaliveIdleTimeS; + int32_t mKeepaliveRetryIntervalS; + int32_t mKeepaliveProbeCount; + + // A Fast Open callback. + TCPFastOpen* mFastOpenCallback; + bool mFastOpenLayerHasBufferedData; + uint8_t mFastOpenStatus; + nsresult mFirstRetryError; + + bool mDoNotRetryToConnect; + + // If the connection is used for QUIC this is set to true. That will mean + // that UDP will be used. QUIC do not have a SocketProvider because it is a + // mix of transport and application(HTTP) level protocol. nsSocketTransport + // will creat a UDP socket and SecInfo(QuicSocketControl). The protocol + // handler will be created by nsHttpconnectionMgr. + bool mUsingQuic; + + // Whether the port remapping has already been applied. We definitely want to + // prevent duplicate calls in case of chaining remapping. + bool mPortRemappingApplied = false; +}; + +} // namespace net +} // namespace mozilla + +#endif // !nsSocketTransport_h__ diff --git a/netwerk/base/nsSocketTransportService2.cpp b/netwerk/base/nsSocketTransportService2.cpp new file mode 100644 index 0000000000..3b2bec6536 --- /dev/null +++ b/netwerk/base/nsSocketTransportService2.cpp @@ -0,0 +1,1892 @@ +// vim:set sw=2 sts=2 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/. */ + +#include "nsSocketTransportService2.h" + +#include "IOActivityMonitor.h" +#include "mozilla/Atomics.h" +#include "mozilla/ChaosMode.h" +#include "mozilla/IntegerPrintfMacros.h" +#include "mozilla/Likely.h" +#include "mozilla/PodOperations.h" +#include "mozilla/Preferences.h" +#include "mozilla/PublicSSL.h" +#include "mozilla/ReverseIterator.h" +#include "mozilla/Services.h" +#include "mozilla/Telemetry.h" +#include "nsASocketHandler.h" +#include "nsError.h" +#include "nsIFile.h" +#include "nsIOService.h" +#include "nsIObserverService.h" +#include "nsIWidget.h" +#include "nsServiceManagerUtils.h" +#include "nsSocketTransport2.h" +#include "nsThreadUtils.h" +#include "prerror.h" +#include "prnetdb.h" + +#ifdef MOZ_TASK_TRACER +# include "GeckoTaskTracer.h" +#endif + +namespace mozilla { +namespace net { + +LazyLogModule gSocketTransportLog("nsSocketTransport"); +LazyLogModule gUDPSocketLog("UDPSocket"); +LazyLogModule gTCPSocketLog("TCPSocket"); + +nsSocketTransportService* gSocketTransportService = nullptr; +static Atomic<PRThread*, Relaxed> gSocketThread(nullptr); + +#define SEND_BUFFER_PREF "network.tcp.sendbuffer" +#define KEEPALIVE_ENABLED_PREF "network.tcp.keepalive.enabled" +#define KEEPALIVE_IDLE_TIME_PREF "network.tcp.keepalive.idle_time" +#define KEEPALIVE_RETRY_INTERVAL_PREF "network.tcp.keepalive.retry_interval" +#define KEEPALIVE_PROBE_COUNT_PREF "network.tcp.keepalive.probe_count" +#define SOCKET_LIMIT_TARGET 1000U +#define SOCKET_LIMIT_MIN 50U +#define MAX_TIME_BETWEEN_TWO_POLLS \ + "network.sts.max_time_for_events_between_two_polls" +#define POLL_BUSY_WAIT_PERIOD "network.sts.poll_busy_wait_period" +#define POLL_BUSY_WAIT_PERIOD_TIMEOUT \ + "network.sts.poll_busy_wait_period_timeout" +#define MAX_TIME_FOR_PR_CLOSE_DURING_SHUTDOWN \ + "network.sts.max_time_for_pr_close_during_shutdown" +#define POLLABLE_EVENT_TIMEOUT "network.sts.pollable_event_timeout" + +#define REPAIR_POLLABLE_EVENT_TIME 10 + +uint32_t nsSocketTransportService::gMaxCount; +PRCallOnceType nsSocketTransportService::gMaxCountInitOnce; + +// Utility functions +bool OnSocketThread() { return PR_GetCurrentThread() == gSocketThread; } + +//----------------------------------------------------------------------------- + +bool nsSocketTransportService::SocketContext::IsTimedOut( + PRIntervalTime now) const { + return TimeoutIn(now) == 0; +} + +void nsSocketTransportService::SocketContext::EnsureTimeout( + PRIntervalTime now) { + SOCKET_LOG(("SocketContext::EnsureTimeout socket=%p", mHandler)); + if (!mPollStartEpoch) { + SOCKET_LOG((" engaging")); + mPollStartEpoch = now; + } +} + +void nsSocketTransportService::SocketContext::DisengageTimeout() { + SOCKET_LOG(("SocketContext::DisengageTimeout socket=%p", mHandler)); + mPollStartEpoch = 0; +} + +PRIntervalTime nsSocketTransportService::SocketContext::TimeoutIn( + PRIntervalTime now) const { + SOCKET_LOG(("SocketContext::TimeoutIn socket=%p, timeout=%us", mHandler, + mHandler->mPollTimeout)); + + if (mHandler->mPollTimeout == UINT16_MAX || !mPollStartEpoch) { + SOCKET_LOG((" not engaged")); + return NS_SOCKET_POLL_TIMEOUT; + } + + PRIntervalTime elapsed = (now - mPollStartEpoch); + PRIntervalTime timeout = PR_SecondsToInterval(mHandler->mPollTimeout); + + if (elapsed >= timeout) { + SOCKET_LOG((" timed out!")); + return 0; + } + SOCKET_LOG((" remains %us", PR_IntervalToSeconds(timeout - elapsed))); + return timeout - elapsed; +} + +void nsSocketTransportService::SocketContext::MaybeResetEpoch() { + if (mPollStartEpoch && mHandler->mPollTimeout == UINT16_MAX) { + mPollStartEpoch = 0; + } +} + +//----------------------------------------------------------------------------- +// ctor/dtor (called on the main/UI thread by the service manager) + +nsSocketTransportService::nsSocketTransportService() + : mRawThread(nullptr), + mInitialized(false), + mShuttingDown(false), + mLock("nsSocketTransportService::mLock"), + mOffline(false), + mGoingOffline(false), + mActiveListSize(SOCKET_LIMIT_MIN), + mIdleListSize(SOCKET_LIMIT_MIN), + mActiveCount(0), + mIdleCount(0), + mSentBytesCount(0), + mReceivedBytesCount(0), + mSendBufferSize(0), + mKeepaliveIdleTimeS(600), + mKeepaliveRetryIntervalS(1), + mKeepaliveProbeCount(kDefaultTCPKeepCount), + mKeepaliveEnabledPref(false), + mPollableEventTimeout(TimeDuration::FromSeconds(6)), + mServingPendingQueue(false), + mMaxTimePerPollIter(100), + mMaxTimeForPrClosePref(PR_SecondsToInterval(5)), + mLastNetworkLinkChangeTime(0), + mNetworkLinkChangeBusyWaitPeriod(PR_SecondsToInterval(50)), + mNetworkLinkChangeBusyWaitTimeout(PR_SecondsToInterval(7)), + mSleepPhase(false), + mProbedMaxCount(false) +#if defined(XP_WIN) + , + mPolling(false) +#endif + , + mNotTrustedMitmDetected(false) { + NS_ASSERTION(NS_IsMainThread(), "wrong thread"); + + PR_CallOnce(&gMaxCountInitOnce, DiscoverMaxCount); + mActiveList = + (SocketContext*)moz_xmalloc(sizeof(SocketContext) * mActiveListSize); + mIdleList = + (SocketContext*)moz_xmalloc(sizeof(SocketContext) * mIdleListSize); + mPollList = + (PRPollDesc*)moz_xmalloc(sizeof(PRPollDesc) * (mActiveListSize + 1)); + + NS_ASSERTION(!gSocketTransportService, "must not instantiate twice"); + gSocketTransportService = this; +} + +void nsSocketTransportService::ApplyPortRemap(uint16_t* aPort) { + MOZ_ASSERT(IsOnCurrentThreadInfallible()); + + if (!mPortRemapping) { + return; + } + + // Reverse the array to make later rules override earlier rules. + for (auto const& portMapping : Reversed(*mPortRemapping)) { + if (*aPort < Get<0>(portMapping)) { + continue; + } + if (*aPort > Get<1>(portMapping)) { + continue; + } + + *aPort = Get<2>(portMapping); + return; + } +} + +bool nsSocketTransportService::UpdatePortRemapPreference( + nsACString const& aPortMappingPref) { + TPortRemapping portRemapping; + + auto consumePreference = [&]() -> bool { + Tokenizer tokenizer(aPortMappingPref); + + tokenizer.SkipWhites(); + if (tokenizer.CheckEOF()) { + return true; + } + + nsTArray<Tuple<uint16_t, uint16_t>> ranges(2); + while (true) { + uint16_t loPort; + tokenizer.SkipWhites(); + if (!tokenizer.ReadInteger(&loPort)) { + break; + } + + uint16_t hiPort; + tokenizer.SkipWhites(); + if (tokenizer.CheckChar('-')) { + tokenizer.SkipWhites(); + if (!tokenizer.ReadInteger(&hiPort)) { + break; + } + } else { + hiPort = loPort; + } + + ranges.AppendElement(MakeTuple(loPort, hiPort)); + + tokenizer.SkipWhites(); + if (tokenizer.CheckChar(',')) { + continue; // another port or port range is expected + } + + if (tokenizer.CheckChar('=')) { + uint16_t targetPort; + tokenizer.SkipWhites(); + if (!tokenizer.ReadInteger(&targetPort)) { + break; + } + + // Storing reversed, because the most common cases (like 443) will very + // likely be listed as first, less common cases will be added to the end + // of the list mapping to the same port. As we iterate the whole + // remapping array from the end, this may have a small perf win by + // hitting the most common cases earlier. + for (auto const& range : Reversed(ranges)) { + portRemapping.AppendElement( + MakeTuple(Get<0>(range), Get<1>(range), targetPort)); + } + ranges.Clear(); + + tokenizer.SkipWhites(); + if (tokenizer.CheckChar(';')) { + continue; // more mappings (or EOF) expected + } + if (tokenizer.CheckEOF()) { + return true; + } + } + + // Anything else is unexpected. + break; + } + + // 'break' from the parsing loop means ill-formed preference + portRemapping.Clear(); + return false; + }; + + bool rv = consumePreference(); + + if (!IsOnCurrentThread()) { + nsCOMPtr<nsIThread> thread = GetThreadSafely(); + if (!thread) { + // Init hasn't been called yet. Could probably just assert. + // If shutdown, the dispatch below will just silently fail. + NS_ASSERTION(false, "ApplyPortRemapPreference before STS::Init"); + return false; + } + thread->Dispatch(NewRunnableMethod<TPortRemapping>( + "net::ApplyPortRemapping", this, + &nsSocketTransportService::ApplyPortRemapPreference, portRemapping)); + } else { + ApplyPortRemapPreference(portRemapping); + } + + return rv; +} + +nsSocketTransportService::~nsSocketTransportService() { + NS_ASSERTION(NS_IsMainThread(), "wrong thread"); + NS_ASSERTION(!mInitialized, "not shutdown properly"); + + free(mActiveList); + free(mIdleList); + free(mPollList); + gSocketTransportService = nullptr; +} + +//----------------------------------------------------------------------------- +// event queue (any thread) + +already_AddRefed<nsIThread> nsSocketTransportService::GetThreadSafely() { + MutexAutoLock lock(mLock); + nsCOMPtr<nsIThread> result = mThread; + return result.forget(); +} + +NS_IMETHODIMP +nsSocketTransportService::DispatchFromScript(nsIRunnable* event, + uint32_t flags) { + nsCOMPtr<nsIRunnable> event_ref(event); + return Dispatch(event_ref.forget(), flags); +} + +NS_IMETHODIMP +nsSocketTransportService::Dispatch(already_AddRefed<nsIRunnable> event, + uint32_t flags) { + nsCOMPtr<nsIRunnable> event_ref(event); + SOCKET_LOG(("STS dispatch [%p]\n", event_ref.get())); + + nsCOMPtr<nsIThread> thread = GetThreadSafely(); + nsresult rv; + rv = thread ? thread->Dispatch(event_ref.forget(), flags) + : NS_ERROR_NOT_INITIALIZED; + if (rv == NS_ERROR_UNEXPECTED) { + // Thread is no longer accepting events. We must have just shut it + // down on the main thread. Pretend we never saw it. + rv = NS_ERROR_NOT_INITIALIZED; + } + return rv; +} + +NS_IMETHODIMP +nsSocketTransportService::DelayedDispatch(already_AddRefed<nsIRunnable>, + uint32_t) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsSocketTransportService::IsOnCurrentThread(bool* result) { + *result = OnSocketThread(); + return NS_OK; +} + +NS_IMETHODIMP_(bool) +nsSocketTransportService::IsOnCurrentThreadInfallible() { + return OnSocketThread(); +} + +//----------------------------------------------------------------------------- +// nsIDirectTaskDispatcher + +already_AddRefed<nsIDirectTaskDispatcher> +nsSocketTransportService::GetDirectTaskDispatcherSafely() { + MutexAutoLock lock(mLock); + nsCOMPtr<nsIDirectTaskDispatcher> result = mDirectTaskDispatcher; + return result.forget(); +} + +NS_IMETHODIMP +nsSocketTransportService::DispatchDirectTask( + already_AddRefed<nsIRunnable> aEvent) { + nsCOMPtr<nsIDirectTaskDispatcher> dispatcher = + GetDirectTaskDispatcherSafely(); + NS_ENSURE_TRUE(dispatcher, NS_ERROR_NOT_INITIALIZED); + return dispatcher->DispatchDirectTask(std::move(aEvent)); +} + +NS_IMETHODIMP nsSocketTransportService::DrainDirectTasks() { + nsCOMPtr<nsIDirectTaskDispatcher> dispatcher = + GetDirectTaskDispatcherSafely(); + if (!dispatcher) { + // nothing to drain. + return NS_OK; + } + return dispatcher->DrainDirectTasks(); +} + +NS_IMETHODIMP nsSocketTransportService::HaveDirectTasks(bool* aValue) { + nsCOMPtr<nsIDirectTaskDispatcher> dispatcher = + GetDirectTaskDispatcherSafely(); + if (!dispatcher) { + *aValue = false; + return NS_OK; + } + return dispatcher->HaveDirectTasks(aValue); +} + +//----------------------------------------------------------------------------- +// socket api (socket thread only) + +NS_IMETHODIMP +nsSocketTransportService::NotifyWhenCanAttachSocket(nsIRunnable* event) { + SOCKET_LOG(("nsSocketTransportService::NotifyWhenCanAttachSocket\n")); + + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + if (CanAttachSocket()) { + return Dispatch(event, NS_DISPATCH_NORMAL); + } + + auto* runnable = new LinkedRunnableEvent(event); + mPendingSocketQueue.insertBack(runnable); + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransportService::AttachSocket(PRFileDesc* fd, + nsASocketHandler* handler) { + SOCKET_LOG( + ("nsSocketTransportService::AttachSocket [handler=%p]\n", handler)); + + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + if (!CanAttachSocket()) { + return NS_ERROR_NOT_AVAILABLE; + } + + SocketContext sock; + sock.mFD = fd; + sock.mHandler = handler; + sock.mPollStartEpoch = 0; + + nsresult rv = AddToIdleList(&sock); + if (NS_SUCCEEDED(rv)) NS_ADDREF(handler); + return rv; +} + +// the number of sockets that can be attached at any given time is +// limited. this is done because some operating systems (e.g., Win9x) +// limit the number of sockets that can be created by an application. +// AttachSocket will fail if the limit is exceeded. consumers should +// call CanAttachSocket and check the result before creating a socket. + +bool nsSocketTransportService::CanAttachSocket() { + static bool reported900FDLimit = false; + + uint32_t total = mActiveCount + mIdleCount; + bool rv = total < gMaxCount; + + if (Telemetry::CanRecordPrereleaseData() && + (((total >= 900) || !rv) && !reported900FDLimit)) { + reported900FDLimit = true; + Telemetry::Accumulate(Telemetry::NETWORK_SESSION_AT_900FD, true); + } + + return rv; +} + +nsresult nsSocketTransportService::DetachSocket(SocketContext* listHead, + SocketContext* sock) { + SOCKET_LOG(("nsSocketTransportService::DetachSocket [handler=%p]\n", + sock->mHandler)); + MOZ_ASSERT((listHead == mActiveList) || (listHead == mIdleList), + "DetachSocket invalid head"); + + { +#ifdef MOZ_TASK_TRACER + tasktracer::AutoSourceEvent taskTracerEvent( + tasktracer::SourceEventType::SocketIO); +#endif + // inform the handler that this socket is going away + sock->mHandler->OnSocketDetached(sock->mFD); + } + mSentBytesCount += sock->mHandler->ByteCountSent(); + mReceivedBytesCount += sock->mHandler->ByteCountReceived(); + + // cleanup + sock->mFD = nullptr; + NS_RELEASE(sock->mHandler); + + if (listHead == mActiveList) + RemoveFromPollList(sock); + else + RemoveFromIdleList(sock); + + // NOTE: sock is now an invalid pointer + + // + // notify the first element on the pending socket queue... + // + nsCOMPtr<nsIRunnable> event; + LinkedRunnableEvent* runnable = mPendingSocketQueue.getFirst(); + if (runnable) { + event = runnable->TakeEvent(); + runnable->remove(); + delete runnable; + } + if (event) { + // move event from pending queue to dispatch queue + return Dispatch(event, NS_DISPATCH_NORMAL); + } + return NS_OK; +} + +nsresult nsSocketTransportService::AddToPollList(SocketContext* sock) { + MOZ_ASSERT(!(static_cast<uint32_t>(sock - mActiveList) < mActiveListSize), + "AddToPollList Socket Already Active"); + + SOCKET_LOG(("nsSocketTransportService::AddToPollList [handler=%p]\n", + sock->mHandler)); + if (mActiveCount == mActiveListSize) { + SOCKET_LOG((" Active List size of %d met\n", mActiveCount)); + if (!GrowActiveList()) { + NS_ERROR("too many active sockets"); + return NS_ERROR_OUT_OF_MEMORY; + } + } + + uint32_t newSocketIndex = mActiveCount; + if (ChaosMode::isActive(ChaosFeature::NetworkScheduling)) { + newSocketIndex = ChaosMode::randomUint32LessThan(mActiveCount + 1); + PodMove(mActiveList + newSocketIndex + 1, mActiveList + newSocketIndex, + mActiveCount - newSocketIndex); + PodMove(mPollList + newSocketIndex + 2, mPollList + newSocketIndex + 1, + mActiveCount - newSocketIndex); + } + + sock->EnsureTimeout(PR_IntervalNow()); + mActiveList[newSocketIndex] = *sock; + mActiveCount++; + + mPollList[newSocketIndex + 1].fd = sock->mFD; + mPollList[newSocketIndex + 1].in_flags = sock->mHandler->mPollFlags; + mPollList[newSocketIndex + 1].out_flags = 0; + + SOCKET_LOG((" active=%u idle=%u\n", mActiveCount, mIdleCount)); + return NS_OK; +} + +void nsSocketTransportService::RemoveFromPollList(SocketContext* sock) { + SOCKET_LOG(("nsSocketTransportService::RemoveFromPollList [handler=%p]\n", + sock->mHandler)); + + uint32_t index = sock - mActiveList; + MOZ_ASSERT(index < mActiveListSize, "invalid index"); + + SOCKET_LOG((" index=%u mActiveCount=%u\n", index, mActiveCount)); + + if (index != mActiveCount - 1) { + mActiveList[index] = mActiveList[mActiveCount - 1]; + mPollList[index + 1] = mPollList[mActiveCount]; + } + mActiveCount--; + + SOCKET_LOG((" active=%u idle=%u\n", mActiveCount, mIdleCount)); +} + +nsresult nsSocketTransportService::AddToIdleList(SocketContext* sock) { + MOZ_ASSERT(!(static_cast<uint32_t>(sock - mIdleList) < mIdleListSize), + "AddToIdlelList Socket Already Idle"); + + SOCKET_LOG(("nsSocketTransportService::AddToIdleList [handler=%p]\n", + sock->mHandler)); + if (mIdleCount == mIdleListSize) { + SOCKET_LOG((" Idle List size of %d met\n", mIdleCount)); + if (!GrowIdleList()) { + NS_ERROR("too many idle sockets"); + return NS_ERROR_OUT_OF_MEMORY; + } + } + + mIdleList[mIdleCount] = *sock; + mIdleCount++; + + SOCKET_LOG((" active=%u idle=%u\n", mActiveCount, mIdleCount)); + return NS_OK; +} + +void nsSocketTransportService::RemoveFromIdleList(SocketContext* sock) { + SOCKET_LOG(("nsSocketTransportService::RemoveFromIdleList [handler=%p]\n", + sock->mHandler)); + + uint32_t index = sock - mIdleList; + NS_ASSERTION(index < mIdleListSize, "invalid index in idle list"); + + if (index != mIdleCount - 1) mIdleList[index] = mIdleList[mIdleCount - 1]; + mIdleCount--; + + SOCKET_LOG((" active=%u idle=%u\n", mActiveCount, mIdleCount)); +} + +void nsSocketTransportService::MoveToIdleList(SocketContext* sock) { + nsresult rv = AddToIdleList(sock); + if (NS_FAILED(rv)) + DetachSocket(mActiveList, sock); + else + RemoveFromPollList(sock); +} + +void nsSocketTransportService::MoveToPollList(SocketContext* sock) { + nsresult rv = AddToPollList(sock); + if (NS_FAILED(rv)) + DetachSocket(mIdleList, sock); + else + RemoveFromIdleList(sock); +} + +bool nsSocketTransportService::GrowActiveList() { + int32_t toAdd = gMaxCount - mActiveListSize; + if (toAdd > 100) { + toAdd = 100; + } else if (toAdd < 1) { + MOZ_ASSERT(false, "CanAttachSocket() should prevent this"); + return false; + } + + mActiveListSize += toAdd; + mActiveList = (SocketContext*)moz_xrealloc( + mActiveList, sizeof(SocketContext) * mActiveListSize); + mPollList = (PRPollDesc*)moz_xrealloc( + mPollList, sizeof(PRPollDesc) * (mActiveListSize + 1)); + return true; +} + +bool nsSocketTransportService::GrowIdleList() { + int32_t toAdd = gMaxCount - mIdleListSize; + if (toAdd > 100) { + toAdd = 100; + } else if (toAdd < 1) { + MOZ_ASSERT(false, "CanAttachSocket() should prevent this"); + return false; + } + + mIdleListSize += toAdd; + mIdleList = (SocketContext*)moz_xrealloc( + mIdleList, sizeof(SocketContext) * mIdleListSize); + return true; +} + +void nsSocketTransportService::ApplyPortRemapPreference( + TPortRemapping const& portRemapping) { + MOZ_ASSERT(IsOnCurrentThreadInfallible()); + + mPortRemapping.reset(); + if (!portRemapping.IsEmpty()) { + mPortRemapping.emplace(portRemapping); + } +} + +PRIntervalTime nsSocketTransportService::PollTimeout(PRIntervalTime now) { + if (mActiveCount == 0) { + return NS_SOCKET_POLL_TIMEOUT; + } + + // compute minimum time before any socket timeout expires. + PRIntervalTime minR = NS_SOCKET_POLL_TIMEOUT; + for (uint32_t i = 0; i < mActiveCount; ++i) { + const SocketContext& s = mActiveList[i]; + PRIntervalTime r = s.TimeoutIn(now); + if (r < minR) { + minR = r; + } + } + if (minR == NS_SOCKET_POLL_TIMEOUT) { + SOCKET_LOG(("poll timeout: none\n")); + return NS_SOCKET_POLL_TIMEOUT; + } + SOCKET_LOG(("poll timeout: %" PRIu32 "\n", PR_IntervalToSeconds(minR))); + return minR; +} + +int32_t nsSocketTransportService::Poll(TimeDuration* pollDuration, + PRIntervalTime ts) { + MOZ_ASSERT(IsOnCurrentThread()); + PRPollDesc* pollList; + uint32_t pollCount; + PRIntervalTime pollTimeout; + *pollDuration = nullptr; + + // If there are pending events for this thread then + // DoPollIteration() should service the network without blocking. + bool pendingEvents = false; + mRawThread->HasPendingEvents(&pendingEvents); + + if (mPollList[0].fd) { + mPollList[0].out_flags = 0; + pollList = mPollList; + pollCount = mActiveCount + 1; + pollTimeout = pendingEvents ? PR_INTERVAL_NO_WAIT : PollTimeout(ts); + } else { + // no pollable event, so busy wait... + pollCount = mActiveCount; + if (pollCount) + pollList = &mPollList[1]; + else + pollList = nullptr; + pollTimeout = + pendingEvents ? PR_INTERVAL_NO_WAIT : PR_MillisecondsToInterval(25); + } + + if ((ts - mLastNetworkLinkChangeTime) < mNetworkLinkChangeBusyWaitPeriod) { + // Being here means we are few seconds after a network change has + // been detected. + PRIntervalTime to = mNetworkLinkChangeBusyWaitTimeout; + if (to) { + pollTimeout = std::min(to, pollTimeout); + SOCKET_LOG((" timeout shorthened after network change event")); + } + } + + TimeStamp pollStart; + if (Telemetry::CanRecordPrereleaseData()) { + pollStart = TimeStamp::NowLoRes(); + } + + SOCKET_LOG((" timeout = %i milliseconds\n", + PR_IntervalToMilliseconds(pollTimeout))); + + int32_t rv = [&]() { + if (pollTimeout != PR_INTERVAL_NO_WAIT) { + // There will be an actual non-zero wait, let the profiler record + // idle time and mark thread as sleeping around the polling call. + AUTO_PROFILER_LABEL("nsSocketTransportService::Poll", IDLE); + AUTO_PROFILER_THREAD_SLEEP; + return PR_Poll(pollList, pollCount, pollTimeout); + } + return PR_Poll(pollList, pollCount, pollTimeout); + }(); + + if (Telemetry::CanRecordPrereleaseData() && !pollStart.IsNull()) { + *pollDuration = TimeStamp::NowLoRes() - pollStart; + } + + SOCKET_LOG((" ...returned after %i milliseconds\n", + PR_IntervalToMilliseconds(PR_IntervalNow() - ts))); + + return rv; +} + +//----------------------------------------------------------------------------- +// xpcom api + +NS_IMPL_ISUPPORTS(nsSocketTransportService, nsISocketTransportService, + nsIRoutedSocketTransportService, nsIEventTarget, + nsISerialEventTarget, nsIThreadObserver, nsIRunnable, + nsPISocketTransportService, nsIObserver, + nsIDirectTaskDispatcher) + +static const char* gCallbackPrefs[] = { + SEND_BUFFER_PREF, + KEEPALIVE_ENABLED_PREF, + KEEPALIVE_IDLE_TIME_PREF, + KEEPALIVE_RETRY_INTERVAL_PREF, + KEEPALIVE_PROBE_COUNT_PREF, + MAX_TIME_BETWEEN_TWO_POLLS, + MAX_TIME_FOR_PR_CLOSE_DURING_SHUTDOWN, + POLLABLE_EVENT_TIMEOUT, + "network.socket.forcePort", + nullptr, +}; + +/* static */ +void nsSocketTransportService::UpdatePrefs(const char* aPref, void* aSelf) { + static_cast<nsSocketTransportService*>(aSelf)->UpdatePrefs(); +} + +// called from main thread only +NS_IMETHODIMP +nsSocketTransportService::Init() { + if (!NS_IsMainThread()) { + NS_ERROR("wrong thread"); + return NS_ERROR_UNEXPECTED; + } + + if (mInitialized) { + return NS_OK; + } + + if (mShuttingDown) { + return NS_ERROR_UNEXPECTED; + } + + nsCOMPtr<nsIThread> thread; + nsresult rv = + NS_NewNamedThread("Socket Thread", getter_AddRefs(thread), this); + NS_ENSURE_SUCCESS(rv, rv); + + { + MutexAutoLock lock(mLock); + // Install our mThread, protecting against concurrent readers + thread.swap(mThread); + mDirectTaskDispatcher = do_QueryInterface(mThread); + } + + MOZ_DIAGNOSTIC_ASSERT( + mDirectTaskDispatcher, + "Underlying thread must support direct task dispatching"); + + Preferences::RegisterCallbacks(UpdatePrefs, gCallbackPrefs, this); + UpdatePrefs(); + + nsCOMPtr<nsIObserverService> obsSvc = services::GetObserverService(); + // Note that the observr notifications are forwarded from parent process to + // socket process. We have to make sure the topics registered below are also + // registered in nsIObserver::Init(). + if (obsSvc) { + obsSvc->AddObserver(this, "profile-initial-state", false); + obsSvc->AddObserver(this, "last-pb-context-exited", false); + obsSvc->AddObserver(this, NS_WIDGET_SLEEP_OBSERVER_TOPIC, true); + obsSvc->AddObserver(this, NS_WIDGET_WAKE_OBSERVER_TOPIC, true); + obsSvc->AddObserver(this, "xpcom-shutdown-threads", false); + obsSvc->AddObserver(this, NS_NETWORK_LINK_TOPIC, false); + } + + // We can now dispatch tasks to the socket thread. + mInitialized = true; + return NS_OK; +} + +// called from main thread only +NS_IMETHODIMP +nsSocketTransportService::Shutdown(bool aXpcomShutdown) { + SOCKET_LOG(("nsSocketTransportService::Shutdown\n")); + + NS_ENSURE_STATE(NS_IsMainThread()); + + if (!mInitialized) { + return NS_OK; + } + + if (mShuttingDown) { + return NS_ERROR_UNEXPECTED; + } + + { + auto observersCopy = mShutdownObservers; + for (auto& observer : observersCopy) { + observer->Observe(); + } + } + + // signal the socket thread to shutdown + mShuttingDown = true; + + { + MutexAutoLock lock(mLock); + + if (mPollableEvent) { + mPollableEvent->Signal(); + } + } + + if (!aXpcomShutdown) { + return ShutdownThread(); + } + + return NS_OK; +} + +nsresult nsSocketTransportService::ShutdownThread() { + SOCKET_LOG(("nsSocketTransportService::ShutdownThread\n")); + + NS_ENSURE_STATE(NS_IsMainThread()); + + if (!mInitialized || !mShuttingDown) { + return NS_OK; + } + + // join with thread + mThread->Shutdown(); + { + MutexAutoLock lock(mLock); + // Drop our reference to mThread and make sure that any concurrent readers + // are excluded + mThread = nullptr; + mDirectTaskDispatcher = nullptr; + } + + Preferences::UnregisterCallbacks(UpdatePrefs, gCallbackPrefs, this); + + nsCOMPtr<nsIObserverService> obsSvc = services::GetObserverService(); + if (obsSvc) { + obsSvc->RemoveObserver(this, "profile-initial-state"); + obsSvc->RemoveObserver(this, "last-pb-context-exited"); + obsSvc->RemoveObserver(this, NS_WIDGET_SLEEP_OBSERVER_TOPIC); + obsSvc->RemoveObserver(this, NS_WIDGET_WAKE_OBSERVER_TOPIC); + obsSvc->RemoveObserver(this, "xpcom-shutdown-threads"); + obsSvc->RemoveObserver(this, NS_NETWORK_LINK_TOPIC); + } + + if (mAfterWakeUpTimer) { + mAfterWakeUpTimer->Cancel(); + mAfterWakeUpTimer = nullptr; + } + + IOActivityMonitor::Shutdown(); + + mInitialized = false; + mShuttingDown = false; + + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransportService::GetOffline(bool* offline) { + *offline = mOffline; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransportService::SetOffline(bool offline) { + MutexAutoLock lock(mLock); + if (!mOffline && offline) { + // signal the socket thread to go offline, so it will detach sockets + mGoingOffline = true; + mOffline = true; + } else if (mOffline && !offline) { + mOffline = false; + } + if (mPollableEvent) { + mPollableEvent->Signal(); + } + + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransportService::GetKeepaliveIdleTime(int32_t* aKeepaliveIdleTimeS) { + MOZ_ASSERT(aKeepaliveIdleTimeS); + if (NS_WARN_IF(!aKeepaliveIdleTimeS)) { + return NS_ERROR_NULL_POINTER; + } + *aKeepaliveIdleTimeS = mKeepaliveIdleTimeS; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransportService::GetKeepaliveRetryInterval( + int32_t* aKeepaliveRetryIntervalS) { + MOZ_ASSERT(aKeepaliveRetryIntervalS); + if (NS_WARN_IF(!aKeepaliveRetryIntervalS)) { + return NS_ERROR_NULL_POINTER; + } + *aKeepaliveRetryIntervalS = mKeepaliveRetryIntervalS; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransportService::GetKeepaliveProbeCount( + int32_t* aKeepaliveProbeCount) { + MOZ_ASSERT(aKeepaliveProbeCount); + if (NS_WARN_IF(!aKeepaliveProbeCount)) { + return NS_ERROR_NULL_POINTER; + } + *aKeepaliveProbeCount = mKeepaliveProbeCount; + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransportService::CreateTransport(const nsTArray<nsCString>& types, + const nsACString& host, int32_t port, + nsIProxyInfo* proxyInfo, + nsISocketTransport** result) { + return CreateRoutedTransport(types, host, port, ""_ns, 0, proxyInfo, result); +} + +NS_IMETHODIMP +nsSocketTransportService::CreateRoutedTransport( + const nsTArray<nsCString>& types, const nsACString& host, int32_t port, + const nsACString& hostRoute, int32_t portRoute, nsIProxyInfo* proxyInfo, + nsISocketTransport** result) { + NS_ENSURE_TRUE(mInitialized, NS_ERROR_NOT_INITIALIZED); + NS_ENSURE_TRUE(port >= 0 && port <= 0xFFFF, NS_ERROR_ILLEGAL_VALUE); + + RefPtr<nsSocketTransport> trans = new nsSocketTransport(); + nsresult rv = trans->Init(types, host, port, hostRoute, portRoute, proxyInfo); + if (NS_FAILED(rv)) { + return rv; + } + + trans.forget(result); + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransportService::CreateUnixDomainTransport( + nsIFile* aPath, nsISocketTransport** result) { +#ifdef XP_UNIX + nsresult rv; + + NS_ENSURE_TRUE(mInitialized, NS_ERROR_NOT_INITIALIZED); + + nsAutoCString path; + rv = aPath->GetNativePath(path); + NS_ENSURE_SUCCESS(rv, rv); + + RefPtr<nsSocketTransport> trans = new nsSocketTransport(); + + rv = trans->InitWithFilename(path.get()); + NS_ENSURE_SUCCESS(rv, rv); + + trans.forget(result); + return NS_OK; +#else + return NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED; +#endif +} + +NS_IMETHODIMP +nsSocketTransportService::CreateUnixDomainAbstractAddressTransport( + const nsACString& aName, nsISocketTransport** result) { + // Abstract socket address is supported on Linux only +#ifdef XP_LINUX + RefPtr<nsSocketTransport> trans = new nsSocketTransport(); + // First character of Abstract socket address is null + UniquePtr<char[]> name(new char[aName.Length() + 1]); + *(name.get()) = 0; + memcpy(name.get() + 1, aName.BeginReading(), aName.Length()); + nsresult rv = trans->InitWithName(name.get(), aName.Length() + 1); + if (NS_FAILED(rv)) { + return rv; + } + + trans.forget(result); + return NS_OK; +#else + return NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED; +#endif +} + +NS_IMETHODIMP +nsSocketTransportService::OnDispatchedEvent() { +#ifndef XP_WIN + // On windows poll can hang and this became worse when we introduced the + // patch for bug 698882 (see also bug 1292181), therefore we reverted the + // behavior on windows to be as before bug 698882, e.g. write to the socket + // also if an event dispatch is on the socket thread and writing to the + // socket for each event. + if (OnSocketThread()) { + // this check is redundant to one done inside ::Signal(), but + // we can do it here and skip obtaining the lock - given that + // this is a relatively common occurance its worth the + // redundant code + SOCKET_LOG(("OnDispatchedEvent Same Thread Skip Signal\n")); + return NS_OK; + } +#else + if (gIOService->IsNetTearingDown()) { + // Poll can hang sometimes. If we are in shutdown, we are going to + // start a watchdog. If we do not exit poll within + // REPAIR_POLLABLE_EVENT_TIME signal a pollable event again. + StartPollWatchdog(); + } +#endif + + MutexAutoLock lock(mLock); + if (mPollableEvent) { + mPollableEvent->Signal(); + } + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransportService::OnProcessNextEvent(nsIThreadInternal* thread, + bool mayWait) { + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransportService::AfterProcessNextEvent(nsIThreadInternal* thread, + bool eventWasProcessed) { + return NS_OK; +} + +void nsSocketTransportService::MarkTheLastElementOfPendingQueue() { + mServingPendingQueue = false; +} + +NS_IMETHODIMP +nsSocketTransportService::Run() { + SOCKET_LOG(("STS thread init %d sockets\n", gMaxCount)); + +#if defined(XP_WIN) + // see bug 1361495, gethostname() triggers winsock initialization. + // so do it here (on parent and child) to protect against it being done first + // accidentally on the main thread.. especially via PR_GetSystemInfo(). This + // will also improve latency of first real winsock operation + // .. + // If STS-thread is no longer needed this should still be run before exiting + + char ignoredStackBuffer[255]; + Unused << gethostname(ignoredStackBuffer, 255); +#endif + + psm::InitializeSSLServerCertVerificationThreads(); + + gSocketThread = PR_GetCurrentThread(); + + { + MutexAutoLock lock(mLock); + mPollableEvent.reset(new PollableEvent()); + // + // NOTE: per bug 190000, this failure could be caused by Zone-Alarm + // or similar software. + // + // NOTE: per bug 191739, this failure could also be caused by lack + // of a loopback device on Windows and OS/2 platforms (it creates + // a loopback socket pair on these platforms to implement a pollable + // event object). if we can't create a pollable event, then we'll + // have to "busy wait" to implement the socket event queue :-( + // + if (!mPollableEvent->Valid()) { + mPollableEvent = nullptr; + NS_WARNING("running socket transport thread without a pollable event"); + SOCKET_LOG(("running socket transport thread without a pollable event")); + } + + mPollList[0].fd = mPollableEvent ? mPollableEvent->PollableFD() : nullptr; + mPollList[0].in_flags = PR_POLL_READ | PR_POLL_EXCEPT; + mPollList[0].out_flags = 0; + } + + mRawThread = NS_GetCurrentThread(); + + // Ensure a call to GetCurrentSerialEventTarget() returns this event target. + SerialEventTargetGuard guard(this); + + // hook ourselves up to observe event processing for this thread + nsCOMPtr<nsIThreadInternal> threadInt = do_QueryInterface(mRawThread); + threadInt->SetObserver(this); + + // make sure the pseudo random number generator is seeded on this thread + srand(static_cast<unsigned>(PR_Now())); + + // For the calculation of the duration of the last cycle (i.e. the last + // for-loop iteration before shutdown). + TimeStamp startOfCycleForLastCycleCalc; + + // For measuring of the poll iteration duration without time spent blocked + // in poll(). + TimeStamp pollCycleStart; + // Time blocked in poll(). + TimeDuration singlePollDuration; + + // For calculating the time needed for a new element to run. + TimeStamp startOfIteration; + TimeStamp startOfNextIteration; + + // If there is too many pending events queued, we will run some poll() + // between them and the following variable is cumulative time spent + // blocking in poll(). + TimeDuration pollDuration; + + for (;;) { + bool pendingEvents = false; + if (Telemetry::CanRecordPrereleaseData()) { + startOfCycleForLastCycleCalc = TimeStamp::NowLoRes(); + startOfNextIteration = TimeStamp::NowLoRes(); + } + pollDuration = nullptr; + // We pop out to this loop when there are no pending events. + // If we don't reset these, we may not re-enter ProcessNextEvent() + // until we have events to process, and it may seem like we have + // an event running for a very long time. + mRawThread->SetRunningEventDelay(TimeDuration(), TimeStamp()); + + do { + if (Telemetry::CanRecordPrereleaseData()) { + pollCycleStart = TimeStamp::NowLoRes(); + } + + DoPollIteration(&singlePollDuration); + + if (Telemetry::CanRecordPrereleaseData() && !pollCycleStart.IsNull()) { + Telemetry::Accumulate(Telemetry::STS_POLL_BLOCK_TIME, + singlePollDuration.ToMilliseconds()); + Telemetry::AccumulateTimeDelta(Telemetry::STS_POLL_CYCLE, + pollCycleStart + singlePollDuration, + TimeStamp::NowLoRes()); + pollDuration += singlePollDuration; + } + + mRawThread->HasPendingEvents(&pendingEvents); + if (pendingEvents) { + if (!mServingPendingQueue) { + nsresult rv = Dispatch( + NewRunnableMethod( + "net::nsSocketTransportService::" + "MarkTheLastElementOfPendingQueue", + this, + &nsSocketTransportService::MarkTheLastElementOfPendingQueue), + nsIEventTarget::DISPATCH_NORMAL); + if (NS_FAILED(rv)) { + NS_WARNING( + "Could not dispatch a new event on the " + "socket thread."); + } else { + mServingPendingQueue = true; + } + + if (Telemetry::CanRecordPrereleaseData()) { + startOfIteration = startOfNextIteration; + // Everything that comes after this point will + // be served in the next iteration. If no even + // arrives, startOfNextIteration will be reset at the + // beginning of each for-loop. + startOfNextIteration = TimeStamp::NowLoRes(); + } + } + TimeStamp eventQueueStart = TimeStamp::NowLoRes(); + do { + NS_ProcessNextEvent(mRawThread); + pendingEvents = false; + mRawThread->HasPendingEvents(&pendingEvents); + } while (pendingEvents && mServingPendingQueue && + ((TimeStamp::NowLoRes() - eventQueueStart).ToMilliseconds() < + mMaxTimePerPollIter)); + + if (Telemetry::CanRecordPrereleaseData() && !mServingPendingQueue && + !startOfIteration.IsNull()) { + Telemetry::AccumulateTimeDelta(Telemetry::STS_POLL_AND_EVENTS_CYCLE, + startOfIteration + pollDuration, + TimeStamp::NowLoRes()); + pollDuration = nullptr; + } + } + } while (pendingEvents); + + bool goingOffline = false; + // now that our event queue is empty, check to see if we should exit + if (mShuttingDown) { + if (Telemetry::CanRecordPrereleaseData() && + !startOfCycleForLastCycleCalc.IsNull()) { + Telemetry::AccumulateTimeDelta( + Telemetry::STS_POLL_AND_EVENT_THE_LAST_CYCLE, + startOfCycleForLastCycleCalc, TimeStamp::NowLoRes()); + } + break; + } + { + MutexAutoLock lock(mLock); + if (mGoingOffline) { + mGoingOffline = false; + goingOffline = true; + } + } + // Avoid potential deadlock + if (goingOffline) { + Reset(true); + } + } + + SOCKET_LOG(("STS shutting down thread\n")); + + // detach all sockets, including locals + Reset(false); + + // We don't clear gSocketThread so that OnSocketThread() won't be a false + // alarm for events generated by stopping the SLL threads during shutdown. + psm::StopSSLServerCertVerificationThreads(); + + // Final pass over the event queue. This makes sure that events posted by + // socket detach handlers get processed. + NS_ProcessPendingEvents(mRawThread); + + SOCKET_LOG(("STS thread exit\n")); + + return NS_OK; +} + +void nsSocketTransportService::DetachSocketWithGuard(bool aGuardLocals, + SocketContext* socketList, + int32_t index) { + bool isGuarded = false; + if (aGuardLocals) { + socketList[index].mHandler->IsLocal(&isGuarded); + if (!isGuarded) socketList[index].mHandler->KeepWhenOffline(&isGuarded); + } + if (!isGuarded) DetachSocket(socketList, &socketList[index]); +} + +void nsSocketTransportService::Reset(bool aGuardLocals) { + // detach any sockets + int32_t i; + for (i = mActiveCount - 1; i >= 0; --i) { + DetachSocketWithGuard(aGuardLocals, mActiveList, i); + } + for (i = mIdleCount - 1; i >= 0; --i) { + DetachSocketWithGuard(aGuardLocals, mIdleList, i); + } +} + +nsresult nsSocketTransportService::DoPollIteration(TimeDuration* pollDuration) { + SOCKET_LOG(("STS poll iter\n")); + + PRIntervalTime now = PR_IntervalNow(); + + int32_t i, count; + // + // poll loop + // + // walk active list backwards to see if any sockets should actually be + // idle, then walk the idle list backwards to see if any idle sockets + // should become active. take care to check only idle sockets that + // were idle to begin with ;-) + // + count = mIdleCount; + for (i = mActiveCount - 1; i >= 0; --i) { + //--- + SOCKET_LOG((" active [%u] { handler=%p condition=%" PRIx32 + " pollflags=%hu }\n", + i, mActiveList[i].mHandler, + static_cast<uint32_t>(mActiveList[i].mHandler->mCondition), + mActiveList[i].mHandler->mPollFlags)); + //--- + if (NS_FAILED(mActiveList[i].mHandler->mCondition)) { + DetachSocket(mActiveList, &mActiveList[i]); + } else { + uint16_t in_flags = mActiveList[i].mHandler->mPollFlags; + if (in_flags == 0) { + MoveToIdleList(&mActiveList[i]); + } else { + // update poll flags + mPollList[i + 1].in_flags = in_flags; + mPollList[i + 1].out_flags = 0; + mActiveList[i].EnsureTimeout(now); + } + } + } + for (i = count - 1; i >= 0; --i) { + //--- + SOCKET_LOG((" idle [%u] { handler=%p condition=%" PRIx32 + " pollflags=%hu }\n", + i, mIdleList[i].mHandler, + static_cast<uint32_t>(mIdleList[i].mHandler->mCondition), + mIdleList[i].mHandler->mPollFlags)); + //--- + if (NS_FAILED(mIdleList[i].mHandler->mCondition)) + DetachSocket(mIdleList, &mIdleList[i]); + else if (mIdleList[i].mHandler->mPollFlags != 0) + MoveToPollList(&mIdleList[i]); + } + + { + MutexAutoLock lock(mLock); + if (mPollableEvent) { + // we want to make sure the timeout is measured from the time + // we enter poll(). This method resets the timestamp to 'now', + // if we were first signalled between leaving poll() and here. + // If we didn't do this and processing events took longer than + // the allowed signal timeout, we would detect it as a + // false-positive. AdjustFirstSignalTimestamp is then a no-op + // until mPollableEvent->Clear() is called. + mPollableEvent->AdjustFirstSignalTimestamp(); + } + } + + SOCKET_LOG( + (" calling PR_Poll [active=%u idle=%u]\n", mActiveCount, mIdleCount)); + +#if defined(XP_WIN) + // 30 active connections is the historic limit before firefox 7's 256. A few + // windows systems have troubles with the higher limit, so actively probe a + // limit the first time we exceed 30. + if ((mActiveCount > 30) && !mProbedMaxCount) ProbeMaxCount(); +#endif + + // Measures seconds spent while blocked on PR_Poll + int32_t n = 0; + *pollDuration = nullptr; + + if (!gIOService->IsNetTearingDown()) { + // Let's not do polling during shutdown. +#if defined(XP_WIN) + StartPolling(); +#endif + n = Poll(pollDuration, now); +#if defined(XP_WIN) + EndPolling(); +#endif + } + + now = PR_IntervalNow(); + + if (n < 0) { + SOCKET_LOG((" PR_Poll error [%d] os error [%d]\n", PR_GetError(), + PR_GetOSError())); + } else { + // + // service "active" sockets... + // + for (i = 0; i < int32_t(mActiveCount); ++i) { + PRPollDesc& desc = mPollList[i + 1]; + SocketContext& s = mActiveList[i]; + if (n > 0 && desc.out_flags != 0) { +#ifdef MOZ_TASK_TRACER + tasktracer::AutoSourceEvent taskTracerEvent( + tasktracer::SourceEventType::SocketIO); +#endif + s.DisengageTimeout(); + s.mHandler->OnSocketReady(desc.fd, desc.out_flags); + } else if (s.IsTimedOut(now)) { +#ifdef MOZ_TASK_TRACER + tasktracer::AutoSourceEvent taskTracerEvent( + tasktracer::SourceEventType::SocketIO); +#endif + SOCKET_LOG(("socket %p timed out", s.mHandler)); + s.DisengageTimeout(); + s.mHandler->OnSocketReady(desc.fd, -1); + } else { + s.MaybeResetEpoch(); + } + } + // + // check for "dead" sockets and remove them (need to do this in + // reverse order obviously). + // + for (i = mActiveCount - 1; i >= 0; --i) { + if (NS_FAILED(mActiveList[i].mHandler->mCondition)) + DetachSocket(mActiveList, &mActiveList[i]); + } + + { + MutexAutoLock lock(mLock); + // acknowledge pollable event (should not block) + if (n != 0 && + (mPollList[0].out_flags & (PR_POLL_READ | PR_POLL_EXCEPT)) && + mPollableEvent && + ((mPollList[0].out_flags & PR_POLL_EXCEPT) || + !mPollableEvent->Clear())) { + // On Windows, the TCP loopback connection in the + // pollable event may become broken when a laptop + // switches between wired and wireless networks or + // wakes up from hibernation. We try to create a + // new pollable event. If that fails, we fall back + // on "busy wait". + TryRepairPollableEvent(); + } + + if (mPollableEvent && + !mPollableEvent->IsSignallingAlive(mPollableEventTimeout)) { + SOCKET_LOG(("Pollable event signalling failed/timed out")); + TryRepairPollableEvent(); + } + } + } + + return NS_OK; +} + +void nsSocketTransportService::UpdateSendBufferPref() { + int32_t bufferSize; + + // If the pref is set, honor it. 0 means use OS defaults. + nsresult rv = Preferences::GetInt(SEND_BUFFER_PREF, &bufferSize); + if (NS_SUCCEEDED(rv)) { + mSendBufferSize = bufferSize; + return; + } + +#if defined(XP_WIN) + mSendBufferSize = 131072 * 4; +#endif +} + +nsresult nsSocketTransportService::UpdatePrefs() { + mSendBufferSize = 0; + + UpdateSendBufferPref(); + + // Default TCP Keepalive Values. + int32_t keepaliveIdleTimeS; + nsresult rv = + Preferences::GetInt(KEEPALIVE_IDLE_TIME_PREF, &keepaliveIdleTimeS); + if (NS_SUCCEEDED(rv)) + mKeepaliveIdleTimeS = clamped(keepaliveIdleTimeS, 1, kMaxTCPKeepIdle); + + int32_t keepaliveRetryIntervalS; + rv = Preferences::GetInt(KEEPALIVE_RETRY_INTERVAL_PREF, + &keepaliveRetryIntervalS); + if (NS_SUCCEEDED(rv)) + mKeepaliveRetryIntervalS = + clamped(keepaliveRetryIntervalS, 1, kMaxTCPKeepIntvl); + + int32_t keepaliveProbeCount; + rv = Preferences::GetInt(KEEPALIVE_PROBE_COUNT_PREF, &keepaliveProbeCount); + if (NS_SUCCEEDED(rv)) + mKeepaliveProbeCount = clamped(keepaliveProbeCount, 1, kMaxTCPKeepCount); + bool keepaliveEnabled = false; + rv = Preferences::GetBool(KEEPALIVE_ENABLED_PREF, &keepaliveEnabled); + if (NS_SUCCEEDED(rv) && keepaliveEnabled != mKeepaliveEnabledPref) { + mKeepaliveEnabledPref = keepaliveEnabled; + OnKeepaliveEnabledPrefChange(); + } + + int32_t maxTimePref; + rv = Preferences::GetInt(MAX_TIME_BETWEEN_TWO_POLLS, &maxTimePref); + if (NS_SUCCEEDED(rv) && maxTimePref >= 0) { + mMaxTimePerPollIter = maxTimePref; + } + + int32_t pollBusyWaitPeriod; + rv = Preferences::GetInt(POLL_BUSY_WAIT_PERIOD, &pollBusyWaitPeriod); + if (NS_SUCCEEDED(rv) && pollBusyWaitPeriod > 0) { + mNetworkLinkChangeBusyWaitPeriod = PR_SecondsToInterval(pollBusyWaitPeriod); + } + + int32_t pollBusyWaitPeriodTimeout; + rv = Preferences::GetInt(POLL_BUSY_WAIT_PERIOD_TIMEOUT, + &pollBusyWaitPeriodTimeout); + if (NS_SUCCEEDED(rv) && pollBusyWaitPeriodTimeout > 0) { + mNetworkLinkChangeBusyWaitTimeout = + PR_SecondsToInterval(pollBusyWaitPeriodTimeout); + } + + int32_t maxTimeForPrClosePref; + rv = Preferences::GetInt(MAX_TIME_FOR_PR_CLOSE_DURING_SHUTDOWN, + &maxTimeForPrClosePref); + if (NS_SUCCEEDED(rv) && maxTimeForPrClosePref >= 0) { + mMaxTimeForPrClosePref = PR_MillisecondsToInterval(maxTimeForPrClosePref); + } + + int32_t pollableEventTimeout; + rv = Preferences::GetInt(POLLABLE_EVENT_TIMEOUT, &pollableEventTimeout); + if (NS_SUCCEEDED(rv) && pollableEventTimeout >= 0) { + MutexAutoLock lock(mLock); + mPollableEventTimeout = TimeDuration::FromSeconds(pollableEventTimeout); + } + + nsAutoCString portMappingPref; + rv = Preferences::GetCString("network.socket.forcePort", portMappingPref); + if (NS_SUCCEEDED(rv)) { + bool rv = UpdatePortRemapPreference(portMappingPref); + if (!rv) { + NS_ERROR( + "network.socket.forcePort preference is ill-formed, this will likely " + "make everything unexpectedly fail!"); + } + } + + return NS_OK; +} + +void nsSocketTransportService::OnKeepaliveEnabledPrefChange() { + // Dispatch to socket thread if we're not executing there. + if (!OnSocketThread()) { + gSocketTransportService->Dispatch( + NewRunnableMethod( + "net::nsSocketTransportService::OnKeepaliveEnabledPrefChange", this, + &nsSocketTransportService::OnKeepaliveEnabledPrefChange), + NS_DISPATCH_NORMAL); + return; + } + + SOCKET_LOG(("nsSocketTransportService::OnKeepaliveEnabledPrefChange %s", + mKeepaliveEnabledPref ? "enabled" : "disabled")); + + // Notify each socket that keepalive has been en/disabled globally. + for (int32_t i = mActiveCount - 1; i >= 0; --i) { + NotifyKeepaliveEnabledPrefChange(&mActiveList[i]); + } + for (int32_t i = mIdleCount - 1; i >= 0; --i) { + NotifyKeepaliveEnabledPrefChange(&mIdleList[i]); + } +} + +void nsSocketTransportService::NotifyKeepaliveEnabledPrefChange( + SocketContext* sock) { + MOZ_ASSERT(sock, "SocketContext cannot be null!"); + MOZ_ASSERT(sock->mHandler, "SocketContext does not have a handler!"); + + if (!sock || !sock->mHandler) { + return; + } + +#ifdef MOZ_TASK_TRACER + tasktracer::AutoSourceEvent taskTracerEvent( + tasktracer::SourceEventType::SocketIO); +#endif + sock->mHandler->OnKeepaliveEnabledPrefChange(mKeepaliveEnabledPref); +} + +NS_IMETHODIMP +nsSocketTransportService::Observe(nsISupports* subject, const char* topic, + const char16_t* data) { + SOCKET_LOG(("nsSocketTransportService::Observe topic=%s", topic)); + + if (!strcmp(topic, "profile-initial-state")) { + if (!Preferences::GetBool(IO_ACTIVITY_ENABLED_PREF, false)) { + return NS_OK; + } + return net::IOActivityMonitor::Init(); + } + + if (!strcmp(topic, "last-pb-context-exited")) { + nsCOMPtr<nsIRunnable> ev = NewRunnableMethod( + "net::nsSocketTransportService::ClosePrivateConnections", this, + &nsSocketTransportService::ClosePrivateConnections); + nsresult rv = Dispatch(ev, nsIEventTarget::DISPATCH_NORMAL); + NS_ENSURE_SUCCESS(rv, rv); + } + + if (!strcmp(topic, NS_TIMER_CALLBACK_TOPIC)) { + nsCOMPtr<nsITimer> timer = do_QueryInterface(subject); + if (timer == mAfterWakeUpTimer) { + mAfterWakeUpTimer = nullptr; + mSleepPhase = false; + } + +#if defined(XP_WIN) + if (timer == mPollRepairTimer) { + DoPollRepair(); + } +#endif + + } else if (!strcmp(topic, NS_WIDGET_SLEEP_OBSERVER_TOPIC)) { + mSleepPhase = true; + if (mAfterWakeUpTimer) { + mAfterWakeUpTimer->Cancel(); + mAfterWakeUpTimer = nullptr; + } + } else if (!strcmp(topic, NS_WIDGET_WAKE_OBSERVER_TOPIC)) { + if (mSleepPhase && !mAfterWakeUpTimer) { + NS_NewTimerWithObserver(getter_AddRefs(mAfterWakeUpTimer), this, 2000, + nsITimer::TYPE_ONE_SHOT); + } + } else if (!strcmp(topic, "xpcom-shutdown-threads")) { + ShutdownThread(); + } else if (!strcmp(topic, NS_NETWORK_LINK_TOPIC)) { + mLastNetworkLinkChangeTime = PR_IntervalNow(); + mNotTrustedMitmDetected = false; + } + + return NS_OK; +} + +void nsSocketTransportService::ClosePrivateConnections() { + MOZ_ASSERT(IsOnCurrentThread(), "Must be called on the socket thread"); + + for (int32_t i = mActiveCount - 1; i >= 0; --i) { + if (mActiveList[i].mHandler->mIsPrivate) { + DetachSocket(mActiveList, &mActiveList[i]); + } + } + for (int32_t i = mIdleCount - 1; i >= 0; --i) { + if (mIdleList[i].mHandler->mIsPrivate) { + DetachSocket(mIdleList, &mIdleList[i]); + } + } + + ClearPrivateSSLState(); +} + +NS_IMETHODIMP +nsSocketTransportService::GetSendBufferSize(int32_t* value) { + *value = mSendBufferSize; + return NS_OK; +} + +/// ugly OS specific includes are placed at the bottom of the src for clarity + +#if defined(XP_WIN) +# include <windows.h> +#elif defined(XP_UNIX) && !defined(AIX) && !defined(NEXTSTEP) && !defined(QNX) +# include <sys/resource.h> +#endif + +// Right now the only need to do this is on windows. +#if defined(XP_WIN) +void nsSocketTransportService::ProbeMaxCount() { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + + if (mProbedMaxCount) { + return; + } + mProbedMaxCount = true; + + // Allocate and test a PR_Poll up to the gMaxCount number of unconnected + // sockets. See bug 692260 - windows should be able to handle 1000 sockets + // in select() without a problem, but LSPs have been known to balk at lower + // numbers. (64 in the bug). + + // Allocate + struct PRPollDesc pfd[SOCKET_LIMIT_TARGET]; + uint32_t numAllocated = 0; + + for (uint32_t index = 0; index < gMaxCount; ++index) { + pfd[index].in_flags = PR_POLL_READ | PR_POLL_WRITE | PR_POLL_EXCEPT; + pfd[index].out_flags = 0; + pfd[index].fd = PR_OpenTCPSocket(PR_AF_INET); + if (!pfd[index].fd) { + SOCKET_LOG(("Socket Limit Test index %d failed\n", index)); + if (index < SOCKET_LIMIT_MIN) + gMaxCount = SOCKET_LIMIT_MIN; + else + gMaxCount = index; + break; + } + ++numAllocated; + } + + // Test + static_assert(SOCKET_LIMIT_MIN >= 32U, "Minimum Socket Limit is >= 32"); + while (gMaxCount <= numAllocated) { + int32_t rv = PR_Poll(pfd, gMaxCount, PR_MillisecondsToInterval(0)); + + SOCKET_LOG(("Socket Limit Test poll() size=%d rv=%d\n", gMaxCount, rv)); + + if (rv >= 0) break; + + SOCKET_LOG(("Socket Limit Test poll confirmationSize=%d rv=%d error=%d\n", + gMaxCount, rv, PR_GetError())); + + gMaxCount -= 32; + if (gMaxCount <= SOCKET_LIMIT_MIN) { + gMaxCount = SOCKET_LIMIT_MIN; + break; + } + } + + // Free + for (uint32_t index = 0; index < numAllocated; ++index) + if (pfd[index].fd) PR_Close(pfd[index].fd); + + Telemetry::Accumulate(Telemetry::NETWORK_PROBE_MAXCOUNT, gMaxCount); + SOCKET_LOG(("Socket Limit Test max was confirmed at %d\n", gMaxCount)); +} +#endif // windows + +PRStatus nsSocketTransportService::DiscoverMaxCount() { + gMaxCount = SOCKET_LIMIT_MIN; + +#if defined(XP_UNIX) && !defined(AIX) && !defined(NEXTSTEP) && !defined(QNX) + // On unix and os x network sockets and file + // descriptors are the same. OS X comes defaulted at 256, + // most linux at 1000. We can reliably use [sg]rlimit to + // query that and raise it if needed. + + struct rlimit rlimitData; + if (getrlimit(RLIMIT_NOFILE, &rlimitData) == -1) // rlimit broken - use min + return PR_SUCCESS; + + if (rlimitData.rlim_cur >= SOCKET_LIMIT_TARGET) { // larger than target! + gMaxCount = SOCKET_LIMIT_TARGET; + return PR_SUCCESS; + } + + int32_t maxallowed = rlimitData.rlim_max; + if ((uint32_t)maxallowed <= SOCKET_LIMIT_MIN) { + return PR_SUCCESS; // so small treat as if rlimit is broken + } + + if ((maxallowed == -1) || // no hard cap - ok to set target + ((uint32_t)maxallowed >= SOCKET_LIMIT_TARGET)) { + maxallowed = SOCKET_LIMIT_TARGET; + } + + rlimitData.rlim_cur = maxallowed; + setrlimit(RLIMIT_NOFILE, &rlimitData); + if ((getrlimit(RLIMIT_NOFILE, &rlimitData) != -1) && + (rlimitData.rlim_cur > SOCKET_LIMIT_MIN)) { + gMaxCount = rlimitData.rlim_cur; + } + +#elif defined(XP_WIN) && !defined(WIN_CE) + // >= XP is confirmed to have at least 1000 + static_assert(SOCKET_LIMIT_TARGET <= 1000, + "SOCKET_LIMIT_TARGET max value is 1000"); + gMaxCount = SOCKET_LIMIT_TARGET; +#else + // other platforms are harder to test - so leave at safe legacy value +#endif + + return PR_SUCCESS; +} + +// Used to return connection info to Dashboard.cpp +void nsSocketTransportService::AnalyzeConnection(nsTArray<SocketInfo>* data, + struct SocketContext* context, + bool aActive) { + if (context->mHandler->mIsPrivate) { + return; + } + PRFileDesc* aFD = context->mFD; + + PRFileDesc* idLayer = PR_GetIdentitiesLayer(aFD, PR_NSPR_IO_LAYER); + + NS_ENSURE_TRUE_VOID(idLayer); + + bool tcp = PR_GetDescType(idLayer) == PR_DESC_SOCKET_TCP; + + PRNetAddr peer_addr; + PodZero(&peer_addr); + PRStatus rv = PR_GetPeerName(aFD, &peer_addr); + if (rv != PR_SUCCESS) { + return; + } + + char host[64] = {0}; + rv = PR_NetAddrToString(&peer_addr, host, sizeof(host)); + if (rv != PR_SUCCESS) { + return; + } + + uint16_t port; + if (peer_addr.raw.family == PR_AF_INET) + port = peer_addr.inet.port; + else + port = peer_addr.ipv6.port; + port = PR_ntohs(port); + uint64_t sent = context->mHandler->ByteCountSent(); + uint64_t received = context->mHandler->ByteCountReceived(); + SocketInfo info = {nsCString(host), sent, received, port, aActive, tcp}; + + data->AppendElement(info); +} + +void nsSocketTransportService::GetSocketConnections( + nsTArray<SocketInfo>* data) { + MOZ_ASSERT(OnSocketThread(), "not on socket thread"); + for (uint32_t i = 0; i < mActiveCount; i++) + AnalyzeConnection(data, &mActiveList[i], true); + for (uint32_t i = 0; i < mIdleCount; i++) + AnalyzeConnection(data, &mIdleList[i], false); +} + +bool nsSocketTransportService::IsTelemetryEnabledAndNotSleepPhase() { + return Telemetry::CanRecordPrereleaseData() && !mSleepPhase; +} + +#if defined(XP_WIN) +void nsSocketTransportService::StartPollWatchdog() { + // Start off the timer from a runnable off of the main thread in order to + // avoid a deadlock, see bug 1370448. + RefPtr<nsSocketTransportService> self(this); + NS_DispatchToMainThread(NS_NewRunnableFunction( + "nsSocketTransportService::StartPollWatchdog", [self] { + MutexAutoLock lock(self->mLock); + + // Poll can hang sometimes. If we are in shutdown, we are going to start + // a watchdog. If we do not exit poll within REPAIR_POLLABLE_EVENT_TIME + // signal a pollable event again. + MOZ_ASSERT(gIOService->IsNetTearingDown()); + if (self->mPolling && !self->mPollRepairTimer) { + NS_NewTimerWithObserver(getter_AddRefs(self->mPollRepairTimer), self, + REPAIR_POLLABLE_EVENT_TIME, + nsITimer::TYPE_REPEATING_SLACK); + } + })); +} + +void nsSocketTransportService::DoPollRepair() { + MutexAutoLock lock(mLock); + if (mPolling && mPollableEvent) { + mPollableEvent->Signal(); + } else if (mPollRepairTimer) { + mPollRepairTimer->Cancel(); + } +} + +void nsSocketTransportService::StartPolling() { + MutexAutoLock lock(mLock); + mPolling = true; +} + +void nsSocketTransportService::EndPolling() { + MutexAutoLock lock(mLock); + mPolling = false; + if (mPollRepairTimer) { + mPollRepairTimer->Cancel(); + } +} + +#endif + +void nsSocketTransportService::TryRepairPollableEvent() { + mLock.AssertCurrentThreadOwns(); + + NS_WARNING("Trying to repair mPollableEvent"); + mPollableEvent.reset(new PollableEvent()); + if (!mPollableEvent->Valid()) { + mPollableEvent = nullptr; + } + SOCKET_LOG( + ("running socket transport thread without " + "a pollable event now valid=%d", + !!mPollableEvent)); + mPollList[0].fd = mPollableEvent ? mPollableEvent->PollableFD() : nullptr; + mPollList[0].in_flags = PR_POLL_READ | PR_POLL_EXCEPT; + mPollList[0].out_flags = 0; +} + +NS_IMETHODIMP +nsSocketTransportService::AddShutdownObserver( + nsISTSShutdownObserver* aObserver) { + mShutdownObservers.AppendElement(aObserver); + return NS_OK; +} + +NS_IMETHODIMP +nsSocketTransportService::RemoveShutdownObserver( + nsISTSShutdownObserver* aObserver) { + mShutdownObservers.RemoveElement(aObserver); + return NS_OK; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/nsSocketTransportService2.h b/netwerk/base/nsSocketTransportService2.h new file mode 100644 index 0000000000..875028c0d6 --- /dev/null +++ b/netwerk/base/nsSocketTransportService2.h @@ -0,0 +1,353 @@ +/* vim:set ts=4 sw=2 sts=2 ci et: */ +/* 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/. */ + +#ifndef nsSocketTransportService2_h__ +#define nsSocketTransportService2_h__ + +#include "PollableEvent.h" +#include "mozilla/Atomics.h" +#include "mozilla/LinkedList.h" +#include "mozilla/Logging.h" +#include "mozilla/Maybe.h" +#include "mozilla/Mutex.h" +#include "mozilla/TimeStamp.h" +#include "mozilla/Tuple.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/net/DashboardTypes.h" +#include "nsCOMPtr.h" +#include "nsIDirectTaskDispatcher.h" +#include "nsIObserver.h" +#include "nsIRunnable.h" +#include "nsIThreadInternal.h" +#include "nsITimer.h" +#include "nsPISocketTransportService.h" +#include "prinit.h" +#include "prinrval.h" + +class nsASocketHandler; +struct PRPollDesc; +class nsIPrefBranch; + +//----------------------------------------------------------------------------- + +namespace mozilla { +namespace net { + +// +// set MOZ_LOG=nsSocketTransport:5 +// +extern LazyLogModule gSocketTransportLog; +#define SOCKET_LOG(args) MOZ_LOG(gSocketTransportLog, LogLevel::Debug, args) +#define SOCKET_LOG1(args) MOZ_LOG(gSocketTransportLog, LogLevel::Error, args) +#define SOCKET_LOG_ENABLED() MOZ_LOG_TEST(gSocketTransportLog, LogLevel::Debug) + +// +// set MOZ_LOG=UDPSocket:5 +// +extern LazyLogModule gUDPSocketLog; +#define UDPSOCKET_LOG(args) MOZ_LOG(gUDPSocketLog, LogLevel::Debug, args) +#define UDPSOCKET_LOG_ENABLED() MOZ_LOG_TEST(gUDPSocketLog, LogLevel::Debug) + +//----------------------------------------------------------------------------- + +#define NS_SOCKET_POLL_TIMEOUT PR_INTERVAL_NO_TIMEOUT + +//----------------------------------------------------------------------------- + +// These maximums are borrowed from the linux kernel. +static const int32_t kMaxTCPKeepIdle = 32767; // ~9 hours. +static const int32_t kMaxTCPKeepIntvl = 32767; +static const int32_t kMaxTCPKeepCount = 127; +static const int32_t kDefaultTCPKeepCount = +#if defined(XP_WIN) + 10; // Hardcoded in Windows. +#elif defined(XP_MACOSX) + 8; // Hardcoded in OSX. +#else + 4; // Specifiable in Linux. +#endif + +class LinkedRunnableEvent final + : public LinkedListElement<LinkedRunnableEvent> { + public: + explicit LinkedRunnableEvent(nsIRunnable* event) : mEvent(event) {} + ~LinkedRunnableEvent() = default; + + already_AddRefed<nsIRunnable> TakeEvent() { return mEvent.forget(); } + + private: + nsCOMPtr<nsIRunnable> mEvent; +}; + +//----------------------------------------------------------------------------- + +class nsSocketTransportService final : public nsPISocketTransportService, + public nsISerialEventTarget, + public nsIThreadObserver, + public nsIRunnable, + public nsIObserver, + public nsIDirectTaskDispatcher { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSPISOCKETTRANSPORTSERVICE + NS_DECL_NSISOCKETTRANSPORTSERVICE + NS_DECL_NSIROUTEDSOCKETTRANSPORTSERVICE + NS_DECL_NSIEVENTTARGET_FULL + NS_DECL_NSITHREADOBSERVER + NS_DECL_NSIRUNNABLE + NS_DECL_NSIOBSERVER + NS_DECL_NSIDIRECTTASKDISPATCHER + + nsSocketTransportService(); + + // Max Socket count may need to get initialized/used by nsHttpHandler + // before this class is initialized. + static uint32_t gMaxCount; + static PRCallOnceType gMaxCountInitOnce; + static PRStatus DiscoverMaxCount(); + + bool CanAttachSocket(); + + // Called by the networking dashboard on the socket thread only + // Fills the passed array with socket information + void GetSocketConnections(nsTArray<SocketInfo>*); + uint64_t GetSentBytes() { return mSentBytesCount; } + uint64_t GetReceivedBytes() { return mReceivedBytesCount; } + + // Returns true if keepalives are enabled in prefs. + bool IsKeepaliveEnabled() { return mKeepaliveEnabledPref; } + + bool IsTelemetryEnabledAndNotSleepPhase(); + PRIntervalTime MaxTimeForPrClosePref() { return mMaxTimeForPrClosePref; } + + void SetNotTrustedMitmDetected() { mNotTrustedMitmDetected = true; } + + // According the preference value of `network.socket.forcePort` this method + // possibly remaps the port number passed as the arg. + void ApplyPortRemap(uint16_t* aPort); + + // Reads the preference string and updates (rewrites) the mPortRemapping + // array on the socket thread. Returns true if the whole pref string was + // correctly formed. + bool UpdatePortRemapPreference(nsACString const& aPortMappingPref); + + protected: + virtual ~nsSocketTransportService(); + + private: + //------------------------------------------------------------------------- + // misc (any thread) + //------------------------------------------------------------------------- + + // The value is guaranteed to be valid and not dangling while on the socket + // thread as mThread is only ever reset after it's been shutdown. + // This member should only ever be read on the socket thread. + nsIThread* mRawThread; + + // Returns mThread in a thread-safe manner. + already_AddRefed<nsIThread> GetThreadSafely(); + // Same as above, but return mThread as a nsIDirectTaskDispatcher + already_AddRefed<nsIDirectTaskDispatcher> GetDirectTaskDispatcherSafely(); + + //------------------------------------------------------------------------- + // initialization and shutdown (any thread) + //------------------------------------------------------------------------- + + Atomic<bool> mInitialized; + // indicates whether we are currently in the process of shutting down + Atomic<bool> mShuttingDown; + Mutex mLock; + // Variables in the next section protected by mLock + + // mThread and mDirectTaskDispatcher are only ever modified on the main + // thread. Will be set on Init and set to null after shutdown. You must access + // mThread and mDirectTaskDispatcher outside the main thread via respectively + // GetThreadSafely and GetDirectTaskDispatchedSafely(). + nsCOMPtr<nsIThread> mThread; + // We store a pointer to mThread as a direct task dispatcher to avoid having + // to do do_QueryInterface whenever we need to access the interface. + nsCOMPtr<nsIDirectTaskDispatcher> mDirectTaskDispatcher; + UniquePtr<PollableEvent> mPollableEvent; + bool mOffline; + bool mGoingOffline; + + // Detaches all sockets. + void Reset(bool aGuardLocals); + + nsresult ShutdownThread(); + + //------------------------------------------------------------------------- + // socket lists (socket thread only) + // + // only "active" sockets are on the poll list. the active list is kept + // in sync with the poll list such that: + // + // mActiveList[k].mFD == mPollList[k+1].fd + // + // where k=0,1,2,... + //------------------------------------------------------------------------- + + struct SocketContext { + PRFileDesc* mFD; + nsASocketHandler* mHandler; + PRIntervalTime mPollStartEpoch; // time we started to poll this socket + + public: + // Returns true iff the socket has not been signalled longer than + // the desired timeout (mHandler->mPollTimeout). + bool IsTimedOut(PRIntervalTime now) const; + // Engages the timeout by marking the epoch we start polling this socket. + // If epoch is already marked this does nothing, hence, this method can be + // called everytime we put this socket to poll() list with in-flags set. + void EnsureTimeout(PRIntervalTime now); + // Called after an event on a socket has been signalled to turn of the + // timeout calculation. + void DisengageTimeout(); + // Returns the number of intervals this socket is about to timeout in, + // or 0 (zero) when it has already timed out. Returns + // NS_SOCKET_POLL_TIMEOUT when there is no timeout set on the socket. + PRIntervalTime TimeoutIn(PRIntervalTime now) const; + // When a socket timeout is reset and later set again, it may happen + // that mPollStartEpoch is not reset in between. We have to manually + // call this on every iteration over sockets to ensure the epoch reset. + void MaybeResetEpoch(); + }; + + SocketContext* mActiveList; /* mListSize entries */ + SocketContext* mIdleList; /* mListSize entries */ + + uint32_t mActiveListSize; + uint32_t mIdleListSize; + uint32_t mActiveCount; + uint32_t mIdleCount; + + nsresult DetachSocket(SocketContext*, SocketContext*); + nsresult AddToIdleList(SocketContext*); + nsresult AddToPollList(SocketContext*); + void RemoveFromIdleList(SocketContext*); + void RemoveFromPollList(SocketContext*); + void MoveToIdleList(SocketContext* sock); + void MoveToPollList(SocketContext* sock); + + bool GrowActiveList(); + bool GrowIdleList(); + void InitMaxCount(); + + // Total bytes number transfered through all the sockets except active ones + uint64_t mSentBytesCount; + uint64_t mReceivedBytesCount; + //------------------------------------------------------------------------- + // poll list (socket thread only) + // + // first element of the poll list is mPollableEvent (or null if the pollable + // event cannot be created). + //------------------------------------------------------------------------- + + PRPollDesc* mPollList; /* mListSize + 1 entries */ + + PRIntervalTime PollTimeout( + PRIntervalTime now); // computes ideal poll timeout + nsresult DoPollIteration(TimeDuration* pollDuration); + // perfoms a single poll iteration + int32_t Poll(TimeDuration* pollDuration, PRIntervalTime now); + // calls PR_Poll. the out param + // interval indicates the poll + // duration in seconds. + // pollDuration is used only for + // telemetry + + //------------------------------------------------------------------------- + // pending socket queue - see NotifyWhenCanAttachSocket + //------------------------------------------------------------------------- + AutoCleanLinkedList<LinkedRunnableEvent> mPendingSocketQueue; + + // Preference Monitor for SendBufferSize and Keepalive prefs. + nsresult UpdatePrefs(); + static void UpdatePrefs(const char* aPref, void* aSelf); + void UpdateSendBufferPref(); + int32_t mSendBufferSize; + // Number of seconds of connection is idle before first keepalive ping. + int32_t mKeepaliveIdleTimeS; + // Number of seconds between retries should keepalive pings fail. + int32_t mKeepaliveRetryIntervalS; + // Number of keepalive probes to send. + int32_t mKeepaliveProbeCount; + // True if TCP keepalive is enabled globally. + bool mKeepaliveEnabledPref; + // Timeout of pollable event signalling. + TimeDuration mPollableEventTimeout; + + Atomic<bool> mServingPendingQueue; + Atomic<int32_t, Relaxed> mMaxTimePerPollIter; + Atomic<PRIntervalTime, Relaxed> mMaxTimeForPrClosePref; + // Timestamp of the last network link change event, tracked + // also on child processes. + Atomic<PRIntervalTime, Relaxed> mLastNetworkLinkChangeTime; + // Preference for how long we do busy wait after network link + // change has been detected. + Atomic<PRIntervalTime, Relaxed> mNetworkLinkChangeBusyWaitPeriod; + // Preference for the value of timeout for poll() we use during + // the network link change event period. + Atomic<PRIntervalTime, Relaxed> mNetworkLinkChangeBusyWaitTimeout; + + // Between a computer going to sleep and waking up the PR_*** telemetry + // will be corrupted - so do not record it. + Atomic<bool, Relaxed> mSleepPhase; + nsCOMPtr<nsITimer> mAfterWakeUpTimer; + + // Lazily created array of forced port remappings. The tuple members meaning + // is exactly: + // <0> the greater-or-equal port number of the range to remap + // <1> the less-or-equal port number of the range to remap + // <2> the port number to remap to, when the given port number falls to the + // range + typedef CopyableTArray<Tuple<uint16_t, uint16_t, uint16_t>> TPortRemapping; + Maybe<TPortRemapping> mPortRemapping; + + // Called on the socket thread to apply the mapping build on the main thread + // from the preference. + void ApplyPortRemapPreference(TPortRemapping const& portRemapping); + + void OnKeepaliveEnabledPrefChange(); + void NotifyKeepaliveEnabledPrefChange(SocketContext* sock); + + // Socket thread only for dynamically adjusting max socket size +#if defined(XP_WIN) + void ProbeMaxCount(); +#endif + bool mProbedMaxCount; + + void AnalyzeConnection(nsTArray<SocketInfo>* data, SocketContext* context, + bool aActive); + + void ClosePrivateConnections(); + void DetachSocketWithGuard(bool aGuardLocals, SocketContext* socketList, + int32_t index); + + void MarkTheLastElementOfPendingQueue(); + +#if defined(XP_WIN) + Atomic<bool> mPolling; + nsCOMPtr<nsITimer> mPollRepairTimer; + void StartPollWatchdog(); + void DoPollRepair(); + void StartPolling(); + void EndPolling(); +#endif + + void TryRepairPollableEvent(); + + bool mNotTrustedMitmDetected; + + CopyableTArray<nsCOMPtr<nsISTSShutdownObserver>> mShutdownObservers; +}; + +extern nsSocketTransportService* gSocketTransportService; +bool OnSocketThread(); + +} // namespace net +} // namespace mozilla + +#endif // !nsSocketTransportService_h__ diff --git a/netwerk/base/nsStandardURL.cpp b/netwerk/base/nsStandardURL.cpp new file mode 100644 index 0000000000..181e3c3d53 --- /dev/null +++ b/netwerk/base/nsStandardURL.cpp @@ -0,0 +1,3717 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=4 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 "IPCMessageUtils.h" + +#include "nsASCIIMask.h" +#include "nsStandardURL.h" +#include "nsCRT.h" +#include "nsEscape.h" +#include "nsIFile.h" +#include "nsIObjectInputStream.h" +#include "nsIObjectOutputStream.h" +#include "nsIIDNService.h" +#include "mozilla/Logging.h" +#include "nsIURLParser.h" +#include "nsNetCID.h" +#include "mozilla/MemoryReporting.h" +#include "mozilla/ipc/URIUtils.h" +#include "mozilla/ScopeExit.h" +#include "mozilla/StaticPrefs_network.h" +#include "mozilla/TextUtils.h" +#include <algorithm> +#include "nsContentUtils.h" +#include "prprf.h" +#include "nsReadableUtils.h" +#include "mozilla/net/MozURL_ffi.h" +#include "mozilla/TextUtils.h" +#include "mozilla/Utf8.h" +#include "nsIClassInfoImpl.h" + +// +// setenv MOZ_LOG nsStandardURL:5 +// +static LazyLogModule gStandardURLLog("nsStandardURL"); + +// The Chromium code defines its own LOG macro which we don't want +#undef LOG +#define LOG(args) MOZ_LOG(gStandardURLLog, LogLevel::Debug, args) +#undef LOG_ENABLED +#define LOG_ENABLED() MOZ_LOG_TEST(gStandardURLLog, LogLevel::Debug) + +using namespace mozilla::ipc; + +namespace mozilla { +namespace net { + +static NS_DEFINE_CID(kThisImplCID, NS_THIS_STANDARDURL_IMPL_CID); +static NS_DEFINE_CID(kStandardURLCID, NS_STANDARDURL_CID); + +// This will always be initialized and destroyed on the main thread, but +// can be safely used on other threads. +StaticRefPtr<nsIIDNService> nsStandardURL::gIDN; + +// This value will only be updated on the main thread once. Worker threads +// may race when reading this values, but that's OK because in the worst +// case we will just dispatch a noop runnable to the main thread. +bool nsStandardURL::gInitialized = false; + +const char nsStandardURL::gHostLimitDigits[] = {'/', '\\', '?', '#', 0}; + +// Invalid host characters +// Note that the array below will be initialized at compile time, +// so we do not need to "optimize" TestForInvalidHostCharacters. +// +constexpr bool TestForInvalidHostCharacters(char c) { + // Testing for these: + // CONTROL_CHARACTERS " #/:?@[\\]*<>|\""; + return (c > 0 && c < 32) || // The control characters are [1, 31] + c == ' ' || c == '#' || c == '/' || c == ':' || c == '?' || c == '@' || + c == '[' || c == '\\' || c == ']' || c == '*' || c == '<' || + c == '^' || +#if defined(MOZ_THUNDERBIRD) || defined(MOZ_SUITE) + // Mailnews %-escapes file paths into URLs. + c == '>' || c == '|' || c == '"'; +#else + c == '>' || c == '|' || c == '"' || c == '%'; +#endif +} +constexpr ASCIIMaskArray sInvalidHostChars = + CreateASCIIMask(TestForInvalidHostCharacters); + +//---------------------------------------------------------------------------- +// nsStandardURL::nsSegmentEncoder +//---------------------------------------------------------------------------- + +nsStandardURL::nsSegmentEncoder::nsSegmentEncoder(const Encoding* encoding) + : mEncoding(encoding) { + if (mEncoding == UTF_8_ENCODING) { + mEncoding = nullptr; + } +} + +int32_t nsStandardURL::nsSegmentEncoder::EncodeSegmentCount( + const char* aStr, const URLSegment& aSeg, int16_t aMask, nsCString& aOut, + bool& aAppended, uint32_t aExtraLen) { + // aExtraLen is characters outside the segment that will be + // added when the segment is not empty (like the @ following + // a username). + if (!aStr || aSeg.mLen <= 0) { + // Empty segment, so aExtraLen not added per above. + aAppended = false; + return 0; + } + + uint32_t origLen = aOut.Length(); + + Span<const char> span = Span(aStr + aSeg.mPos, aSeg.mLen); + + // first honor the origin charset if appropriate. as an optimization, + // only do this if the segment is non-ASCII. Further, if mEncoding is + // null, then the origin charset is UTF-8 and there is nothing to do. + if (mEncoding) { + size_t upTo; + if (MOZ_UNLIKELY(mEncoding == ISO_2022_JP_ENCODING)) { + upTo = Encoding::ISO2022JPASCIIValidUpTo(AsBytes(span)); + } else { + upTo = Encoding::ASCIIValidUpTo(AsBytes(span)); + } + if (upTo != span.Length()) { + // we have to encode this segment + char bufferArr[512]; + Span<char> buffer = Span(bufferArr); + + auto encoder = mEncoding->NewEncoder(); + + nsAutoCString valid; // has to be declared in this scope + if (MOZ_UNLIKELY(!IsUtf8(span.From(upTo)))) { + MOZ_ASSERT_UNREACHABLE("Invalid UTF-8 passed to nsStandardURL."); + // It's UB to pass invalid UTF-8 to + // EncodeFromUTF8WithoutReplacement(), so let's make our input valid + // UTF-8 by replacing invalid sequences with the REPLACEMENT + // CHARACTER. + UTF_8_ENCODING->Decode( + nsDependentCSubstring(span.Elements(), span.Length()), valid); + // This assigment is OK. `span` can't be used after `valid` has + // been destroyed because the only way out of the scope that `valid` + // was declared in is via return inside the loop below. Specifically, + // the return is the only way out of the loop. + span = valid; + } + + size_t totalRead = 0; + for (;;) { + uint32_t encoderResult; + size_t read; + size_t written; + Tie(encoderResult, read, written) = + encoder->EncodeFromUTF8WithoutReplacement( + AsBytes(span.From(totalRead)), AsWritableBytes(buffer), true); + totalRead += read; + auto bufferWritten = buffer.To(written); + if (!NS_EscapeURLSpan(bufferWritten, aMask, aOut)) { + aOut.Append(bufferWritten); + } + if (encoderResult == kInputEmpty) { + aAppended = true; + // Difference between original and current output + // string lengths plus extra length + return aOut.Length() - origLen + aExtraLen; + } + if (encoderResult == kOutputFull) { + continue; + } + aOut.AppendLiteral("%26%23"); + aOut.AppendInt(encoderResult); + aOut.AppendLiteral("%3B"); + } + MOZ_RELEASE_ASSERT( + false, + "There's supposed to be no way out of the above loop except return."); + } + } + + if (NS_EscapeURLSpan(span, aMask, aOut)) { + aAppended = true; + // Difference between original and current output + // string lengths plus extra length + return aOut.Length() - origLen + aExtraLen; + } + aAppended = false; + // Original segment length plus extra length + return span.Length() + aExtraLen; +} + +const nsACString& nsStandardURL::nsSegmentEncoder::EncodeSegment( + const nsACString& str, int16_t mask, nsCString& result) { + const char* text; + bool encoded; + EncodeSegmentCount(str.BeginReading(text), URLSegment(0, str.Length()), mask, + result, encoded); + if (encoded) { + return result; + } + return str; +} + +//---------------------------------------------------------------------------- +// nsStandardURL <public> +//---------------------------------------------------------------------------- + +#ifdef DEBUG_DUMP_URLS_AT_SHUTDOWN +static StaticMutex gAllURLsMutex; +static LinkedList<nsStandardURL> gAllURLs; +#endif + +nsStandardURL::nsStandardURL(bool aSupportsFileURL, bool aTrackURL) + : mDefaultPort(-1), + mPort(-1), + mDisplayHost(nullptr), + mURLType(URLTYPE_STANDARD), + mSupportsFileURL(aSupportsFileURL), + mCheckedIfHostA(false) { + LOG(("Creating nsStandardURL @%p\n", this)); + + // gInitialized changes value only once (false->true) on the main thread. + // It's OK to race here because in the worst case we'll just + // dispatch a noop runnable to the main thread. + MOZ_ASSERT(gInitialized); + + // default parser in case nsIStandardURL::Init is never called + mParser = net_GetStdURLParser(); + +#ifdef DEBUG_DUMP_URLS_AT_SHUTDOWN + if (aTrackURL) { + StaticMutexAutoLock lock(gAllURLsMutex); + gAllURLs.insertBack(this); + } +#endif +} + +// static +void nsStandardURL::SanityCheck(const URLSegment& aSeg, + const nsCString& aSpec) { + MOZ_RELEASE_ASSERT(aSeg.mLen >= -1); + MOZ_RELEASE_ASSERT(aSeg.mLen < 0 || + (aSeg.mPos + aSeg.mLen <= aSpec.Length() && + aSeg.mPos + aSeg.mLen >= aSeg.mPos)); +} + +nsStandardURL::~nsStandardURL() { + LOG(("Destroying nsStandardURL @%p\n", this)); + +#ifdef DEBUG_DUMP_URLS_AT_SHUTDOWN + { + StaticMutexAutoLock lock(gAllURLsMutex); + if (isInList()) { + remove(); + } + } +#endif + + SanityCheck(mScheme, mSpec); + SanityCheck(mAuthority, mSpec); + SanityCheck(mUsername, mSpec); + SanityCheck(mPassword, mSpec); + SanityCheck(mHost, mSpec); + SanityCheck(mPath, mSpec); + SanityCheck(mFilepath, mSpec); + SanityCheck(mDirectory, mSpec); + SanityCheck(mBasename, mSpec); + SanityCheck(mExtension, mSpec); + SanityCheck(mQuery, mSpec); + SanityCheck(mRef, mSpec); +} + +#ifdef DEBUG_DUMP_URLS_AT_SHUTDOWN +struct DumpLeakedURLs { + DumpLeakedURLs() = default; + ~DumpLeakedURLs(); +}; + +DumpLeakedURLs::~DumpLeakedURLs() { + MOZ_ASSERT(NS_IsMainThread()); + StaticMutexAutoLock lock(gAllURLsMutex); + if (!gAllURLs.isEmpty()) { + printf("Leaked URLs:\n"); + for (auto* url : gAllURLs) { + url->PrintSpec(); + } + gAllURLs.clear(); + } +} +#endif + +void nsStandardURL::InitGlobalObjects() { + MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread()); + + if (gInitialized) { + return; + } + + gInitialized = true; + + nsCOMPtr<nsIIDNService> serv(do_GetService(NS_IDNSERVICE_CONTRACTID)); + if (serv) { + gIDN = serv; + } + MOZ_DIAGNOSTIC_ASSERT(gIDN); + + // Make sure nsURLHelper::InitGlobals() gets called on the main thread + nsCOMPtr<nsIURLParser> parser = net_GetStdURLParser(); + MOZ_DIAGNOSTIC_ASSERT(parser); + Unused << parser; +} + +void nsStandardURL::ShutdownGlobalObjects() { + MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread()); + gIDN = nullptr; + +#ifdef DEBUG_DUMP_URLS_AT_SHUTDOWN + if (gInitialized) { + // This instanciates a dummy class, and will trigger the class + // destructor when libxul is unloaded. This is equivalent to atexit(), + // but gracefully handles dlclose(). + StaticMutexAutoLock lock(gAllURLsMutex); + static DumpLeakedURLs d; + } +#endif +} + +//---------------------------------------------------------------------------- +// nsStandardURL <private> +//---------------------------------------------------------------------------- + +void nsStandardURL::Clear() { + mSpec.Truncate(); + + mPort = -1; + + mScheme.Reset(); + mAuthority.Reset(); + mUsername.Reset(); + mPassword.Reset(); + mHost.Reset(); + + mPath.Reset(); + mFilepath.Reset(); + mDirectory.Reset(); + mBasename.Reset(); + + mExtension.Reset(); + mQuery.Reset(); + mRef.Reset(); + + InvalidateCache(); +} + +void nsStandardURL::InvalidateCache(bool invalidateCachedFile) { + if (invalidateCachedFile) { + mFile = nullptr; + } +} + +// Return the number of "dots" in the string, or -1 if invalid. Note that the +// number of relevant entries in the bases/starts/ends arrays is number of +// dots + 1. +// Since the trailing dot is allowed, we pass and adjust "length". +// +// length is assumed to be <= host.Length(); the callers is responsible for that +// +// Note that the value returned is guaranteed to be in [-1, 3] range. +inline int32_t ValidateIPv4Number(const nsACString& host, int32_t bases[4], + int32_t dotIndex[3], bool& onlyBase10, + int32_t& length) { + MOZ_ASSERT(length <= (int32_t)host.Length()); + if (length <= 0) { + return -1; + } + + bool lastWasNumber = false; // We count on this being false for i == 0 + int32_t dotCount = 0; + onlyBase10 = true; + + for (int32_t i = 0; i < length; i++) { + char current = host[i]; + if (current == '.') { + if (!lastWasNumber) { // A dot should not follow an X or a dot, or be + // first + return -1; + } + + if (dotCount > 0 && + i == (length - 1)) { // Trailing dot is OK; shorten and return + length--; + return dotCount; + } + + if (dotCount > 2) { + return -1; + } + lastWasNumber = false; + dotIndex[dotCount] = i; + dotCount++; + } else if (current == 'X' || current == 'x') { + if (!lastWasNumber || // An X should not follow an X or a dot or be first + i == (length - 1) || // No trailing Xs allowed + (dotCount == 0 && + i != 1) || // If we had no dots, an X should be second + host[i - 1] != '0' || // X should always follow a 0. Guaranteed i > + // 0 as lastWasNumber is true + (dotCount > 0 && + host[i - 2] != '.')) { // And that zero follows a dot if it exists + return -1; + } + lastWasNumber = false; + bases[dotCount] = 16; + onlyBase10 = false; + + } else if (current == '0') { + if (i < length - 1 && // Trailing zero doesn't signal octal + host[i + 1] != '.' && // Lone zero is not octal + (i == 0 || host[i - 1] == '.')) { // Zero at start or following a dot + // is a candidate for octal + bases[dotCount] = 8; // This will turn to 16 above if X shows up + onlyBase10 = false; + } + lastWasNumber = true; + + } else if (current >= '1' && current <= '7') { + lastWasNumber = true; + + } else if (current >= '8' && current <= '9') { + if (bases[dotCount] == 8) { + return -1; + } + lastWasNumber = true; + + } else if ((current >= 'a' && current <= 'f') || + (current >= 'A' && current <= 'F')) { + if (bases[dotCount] != 16) { + return -1; + } + lastWasNumber = true; + + } else { + return -1; + } + } + + return dotCount; +} + +inline nsresult ParseIPv4Number10(const nsACString& input, uint32_t& number, + uint32_t maxNumber) { + uint64_t value = 0; + const char* current = input.BeginReading(); + const char* end = input.EndReading(); + for (; current < end; ++current) { + char c = *current; + MOZ_ASSERT(c >= '0' && c <= '9'); + value *= 10; + value += c - '0'; + } + if (value <= maxNumber) { + number = value; + return NS_OK; + } + + // The error case + number = 0; + return NS_ERROR_FAILURE; +} + +inline nsresult ParseIPv4Number(const nsACString& input, int32_t base, + uint32_t& number, uint32_t maxNumber) { + // Accumulate in the 64-bit value + uint64_t value = 0; + const char* current = input.BeginReading(); + const char* end = input.EndReading(); + switch (base) { + case 16: + ++current; + [[fallthrough]]; + case 8: + ++current; + break; + case 10: + default: + break; + } + for (; current < end; ++current) { + value *= base; + char c = *current; + MOZ_ASSERT((base == 10 && IsAsciiDigit(c)) || + (base == 8 && c >= '0' && c <= '7') || + (base == 16 && IsAsciiHexDigit(c))); + if (IsAsciiDigit(c)) { + value += c - '0'; + } else if (c >= 'a' && c <= 'f') { + value += c - 'a' + 10; + } else if (c >= 'A' && c <= 'F') { + value += c - 'A' + 10; + } + } + + if (value <= maxNumber) { + number = value; + return NS_OK; + } + + // The error case + number = 0; + return NS_ERROR_FAILURE; +} + +// IPv4 parser spec: https://url.spec.whatwg.org/#concept-ipv4-parser +/* static */ +nsresult nsStandardURL::NormalizeIPv4(const nsACString& host, + nsCString& result) { + int32_t bases[4] = {10, 10, 10, 10}; + bool onlyBase10 = true; // Track this as a special case + int32_t dotIndex[3]; // The positions of the dots in the string + + // The length may be adjusted by ValidateIPv4Number (ignoring the trailing + // period) so use "length", rather than host.Length() after that call. + int32_t length = static_cast<int32_t>(host.Length()); + int32_t dotCount = + ValidateIPv4Number(host, bases, dotIndex, onlyBase10, length); + if (dotCount < 0 || length <= 0) { + return NS_ERROR_FAILURE; + } + + // Max values specified by the spec + static const uint32_t upperBounds[] = {0xffffffffu, 0xffffffu, 0xffffu, + 0xffu}; + uint32_t ipv4; + int32_t start = (dotCount > 0 ? dotIndex[dotCount - 1] + 1 : 0); + + nsresult res; + // Doing a special case for all items being base 10 gives ~35% speedup + res = (onlyBase10 + ? ParseIPv4Number10(Substring(host, start, length - start), ipv4, + upperBounds[dotCount]) + : ParseIPv4Number(Substring(host, start, length - start), + bases[dotCount], ipv4, upperBounds[dotCount])); + if (NS_FAILED(res)) { + return NS_ERROR_FAILURE; + } + + int32_t lastUsed = -1; + for (int32_t i = 0; i < dotCount; i++) { + uint32_t number; + start = lastUsed + 1; + lastUsed = dotIndex[i]; + res = + (onlyBase10 ? ParseIPv4Number10( + Substring(host, start, lastUsed - start), number, 255) + : ParseIPv4Number(Substring(host, start, lastUsed - start), + bases[i], number, 255)); + if (NS_FAILED(res)) { + return NS_ERROR_FAILURE; + } + ipv4 += number << (8 * (3 - i)); + } + + uint8_t ipSegments[4]; + NetworkEndian::writeUint32(ipSegments, ipv4); + result = nsPrintfCString("%d.%d.%d.%d", ipSegments[0], ipSegments[1], + ipSegments[2], ipSegments[3]); + return NS_OK; +} + +nsresult nsStandardURL::NormalizeIDN(const nsACString& host, + nsCString& result) { + // If host is ACE, then convert to UTF-8. Else, if host is already UTF-8, + // then make sure it is normalized per IDN. + + // this function returns true if normalization succeeds. + + result.Truncate(); + nsresult rv; + + if (!gIDN) { + return NS_ERROR_UNEXPECTED; + } + + bool isAscii; + nsAutoCString normalized; + rv = gIDN->ConvertToDisplayIDN(host, &isAscii, normalized); + if (NS_FAILED(rv)) { + return rv; + } + + // The result is ASCII. No need to convert to ACE. + if (isAscii) { + result = normalized; + mCheckedIfHostA = true; + mDisplayHost.Truncate(); + return NS_OK; + } + + rv = gIDN->ConvertUTF8toACE(normalized, result); + if (NS_FAILED(rv)) { + return rv; + } + + mCheckedIfHostA = true; + mDisplayHost = normalized; + + return NS_OK; +} + +bool nsStandardURL::ValidIPv6orHostname(const char* host, uint32_t length) { + if (!host || !*host) { + // Should not be NULL or empty string + return false; + } + + if (length != strlen(host)) { + // Embedded null + return false; + } + + bool openBracket = host[0] == '['; + bool closeBracket = host[length - 1] == ']'; + + if (openBracket && closeBracket) { + return net_IsValidIPv6Addr(Substring(host + 1, length - 2)); + } + + if (openBracket || closeBracket) { + // Fail if only one of the brackets is present + return false; + } + + const char* end = host + length; + const char* iter = host; + for (; iter != end && *iter; ++iter) { + if (ASCIIMask::IsMasked(sInvalidHostChars, *iter)) { + return false; + } + } + return true; +} + +void nsStandardURL::CoalescePath(netCoalesceFlags coalesceFlag, char* path) { + net_CoalesceDirs(coalesceFlag, path); + int32_t newLen = strlen(path); + if (newLen < mPath.mLen) { + int32_t diff = newLen - mPath.mLen; + mPath.mLen = newLen; + mDirectory.mLen += diff; + mFilepath.mLen += diff; + ShiftFromBasename(diff); + } +} + +uint32_t nsStandardURL::AppendSegmentToBuf(char* buf, uint32_t i, + const char* str, + const URLSegment& segInput, + URLSegment& segOutput, + const nsCString* escapedStr, + bool useEscaped, int32_t* diff) { + MOZ_ASSERT(segInput.mLen == segOutput.mLen); + + if (diff) { + *diff = 0; + } + + if (segInput.mLen > 0) { + if (useEscaped) { + MOZ_ASSERT(diff); + segOutput.mLen = escapedStr->Length(); + *diff = segOutput.mLen - segInput.mLen; + memcpy(buf + i, escapedStr->get(), segOutput.mLen); + } else { + memcpy(buf + i, str + segInput.mPos, segInput.mLen); + } + segOutput.mPos = i; + i += segOutput.mLen; + } else { + segOutput.mPos = i; + } + return i; +} + +uint32_t nsStandardURL::AppendToBuf(char* buf, uint32_t i, const char* str, + uint32_t len) { + memcpy(buf + i, str, len); + return i + len; +} + +// basic algorithm: +// 1- escape url segments (for improved GetSpec efficiency) +// 2- allocate spec buffer +// 3- write url segments +// 4- update url segment positions and lengths +nsresult nsStandardURL::BuildNormalizedSpec(const char* spec, + const Encoding* encoding) { + // Assumptions: all member URLSegments must be relative the |spec| argument + // passed to this function. + + // buffers for holding escaped url segments (these will remain empty unless + // escaping is required). + nsAutoCString encUsername, encPassword, encHost, encDirectory, encBasename, + encExtension, encQuery, encRef; + bool useEncUsername, useEncPassword, useEncHost = false, useEncDirectory, + useEncBasename, useEncExtension, + useEncQuery, useEncRef; + nsAutoCString portbuf; + + // + // escape each URL segment, if necessary, and calculate approximate normalized + // spec length. + // + // [scheme://][username[:password]@]host[:port]/path[?query_string][#ref] + + uint32_t approxLen = 0; + + // the scheme is already ASCII + if (mScheme.mLen > 0) { + approxLen += + mScheme.mLen + 3; // includes room for "://", which we insert always + } + + // encode URL segments; convert UTF-8 to origin charset and possibly escape. + // results written to encXXX variables only if |spec| is not already in the + // appropriate encoding. + { + nsSegmentEncoder encoder; + nsSegmentEncoder queryEncoder(encoding); + // Username@ + approxLen += encoder.EncodeSegmentCount(spec, mUsername, esc_Username, + encUsername, useEncUsername, 0); + approxLen += 1; // reserve length for @ + // :password - we insert the ':' even if there's no actual password if + // "user:@" was in the spec + if (mPassword.mLen > 0) { + approxLen += 1 + encoder.EncodeSegmentCount(spec, mPassword, esc_Password, + encPassword, useEncPassword); + } + // mHost is handled differently below due to encoding differences + MOZ_ASSERT(mPort >= -1, "Invalid negative mPort"); + if (mPort != -1 && mPort != mDefaultPort) { + // :port + portbuf.AppendInt(mPort); + approxLen += portbuf.Length() + 1; + } + + approxLen += + 1; // reserve space for possible leading '/' - may not be needed + // Should just use mPath? These are pessimistic, and thus waste space + approxLen += encoder.EncodeSegmentCount(spec, mDirectory, esc_Directory, + encDirectory, useEncDirectory, 1); + approxLen += encoder.EncodeSegmentCount(spec, mBasename, esc_FileBaseName, + encBasename, useEncBasename); + approxLen += encoder.EncodeSegmentCount(spec, mExtension, esc_FileExtension, + encExtension, useEncExtension, 1); + + // These next ones *always* add their leading character even if length is 0 + // Handles items like "http://#" + // ?query + if (mQuery.mLen >= 0) { + approxLen += 1 + queryEncoder.EncodeSegmentCount(spec, mQuery, esc_Query, + encQuery, useEncQuery); + } + // #ref + + if (mRef.mLen >= 0) { + approxLen += 1 + encoder.EncodeSegmentCount(spec, mRef, esc_Ref, encRef, + useEncRef); + } + } + + // do not escape the hostname, if IPv6 address literal, mHost will + // already point to a [ ] delimited IPv6 address literal. + // However, perform Unicode normalization on it, as IDN does. + // Note that we don't disallow URLs without a host - file:, etc + if (mHost.mLen > 0) { + nsAutoCString tempHost; + NS_UnescapeURL(spec + mHost.mPos, mHost.mLen, esc_AlwaysCopy | esc_Host, + tempHost); + if (tempHost.Contains('\0')) { + return NS_ERROR_MALFORMED_URI; // null embedded in hostname + } + if (tempHost.Contains(' ')) { + return NS_ERROR_MALFORMED_URI; // don't allow spaces in the hostname + } + nsresult rv = NormalizeIDN(tempHost, encHost); + if (NS_FAILED(rv)) { + return rv; + } + if (!SegmentIs(spec, mScheme, "resource") && + !SegmentIs(spec, mScheme, "chrome")) { + nsAutoCString ipString; + if (encHost.Length() > 0 && encHost.First() == '[' && + encHost.Last() == ']' && + ValidIPv6orHostname(encHost.get(), encHost.Length())) { + rv = (nsresult)rusturl_parse_ipv6addr(&encHost, &ipString); + if (NS_FAILED(rv)) { + return rv; + } + encHost = ipString; + } else if (NS_SUCCEEDED(NormalizeIPv4(encHost, ipString))) { + encHost = ipString; + } + } + + // NormalizeIDN always copies, if the call was successful. + useEncHost = true; + approxLen += encHost.Length(); + + if (!ValidIPv6orHostname(encHost.BeginReading(), encHost.Length())) { + return NS_ERROR_MALFORMED_URI; + } + } else { + // empty host means empty mDisplayHost + mDisplayHost.Truncate(); + mCheckedIfHostA = true; + } + + // We must take a copy of every single segment because they are pointing to + // the |spec| while we are changing their value, in case we must use + // encoded strings. + URLSegment username(mUsername); + URLSegment password(mPassword); + URLSegment host(mHost); + URLSegment path(mPath); + URLSegment directory(mDirectory); + URLSegment basename(mBasename); + URLSegment extension(mExtension); + URLSegment query(mQuery); + URLSegment ref(mRef); + + // The encoded string could be longer than the original input, so we need + // to check the final URI isn't longer than the max length. + if (approxLen + 1 > StaticPrefs::network_standard_url_max_length()) { + return NS_ERROR_MALFORMED_URI; + } + + // + // generate the normalized URL string + // + // approxLen should be correct or 1 high + if (!mSpec.SetLength(approxLen + 1, + fallible)) { // buf needs a trailing '\0' below + return NS_ERROR_OUT_OF_MEMORY; + } + char* buf = mSpec.BeginWriting(); + uint32_t i = 0; + int32_t diff = 0; + + if (mScheme.mLen > 0) { + i = AppendSegmentToBuf(buf, i, spec, mScheme, mScheme); + net_ToLowerCase(buf + mScheme.mPos, mScheme.mLen); + i = AppendToBuf(buf, i, "://", 3); + } + + // record authority starting position + mAuthority.mPos = i; + + // append authority + if (mUsername.mLen > 0 || mPassword.mLen > 0) { + if (mUsername.mLen > 0) { + i = AppendSegmentToBuf(buf, i, spec, username, mUsername, &encUsername, + useEncUsername, &diff); + ShiftFromPassword(diff); + } else { + mUsername.mLen = -1; + } + if (password.mLen > 0) { + buf[i++] = ':'; + i = AppendSegmentToBuf(buf, i, spec, password, mPassword, &encPassword, + useEncPassword, &diff); + ShiftFromHost(diff); + } else { + mPassword.mLen = -1; + } + buf[i++] = '@'; + } else { + mUsername.mLen = -1; + mPassword.mLen = -1; + } + if (host.mLen > 0) { + i = AppendSegmentToBuf(buf, i, spec, host, mHost, &encHost, useEncHost, + &diff); + ShiftFromPath(diff); + + net_ToLowerCase(buf + mHost.mPos, mHost.mLen); + MOZ_ASSERT(mPort >= -1, "Invalid negative mPort"); + if (mPort != -1 && mPort != mDefaultPort) { + buf[i++] = ':'; + // Already formatted while building approxLen + i = AppendToBuf(buf, i, portbuf.get(), portbuf.Length()); + } + } + + // record authority length + mAuthority.mLen = i - mAuthority.mPos; + + // path must always start with a "/" + if (mPath.mLen <= 0) { + LOG(("setting path=/")); + mDirectory.mPos = mFilepath.mPos = mPath.mPos = i; + mDirectory.mLen = mFilepath.mLen = mPath.mLen = 1; + // basename must exist, even if empty (bug 113508) + mBasename.mPos = i + 1; + mBasename.mLen = 0; + buf[i++] = '/'; + } else { + uint32_t leadingSlash = 0; + if (spec[path.mPos] != '/') { + LOG(("adding leading slash to path\n")); + leadingSlash = 1; + buf[i++] = '/'; + // basename must exist, even if empty (bugs 113508, 429347) + if (mBasename.mLen == -1) { + mBasename.mPos = basename.mPos = i; + mBasename.mLen = basename.mLen = 0; + } + } + + // record corrected (file)path starting position + mPath.mPos = mFilepath.mPos = i - leadingSlash; + + i = AppendSegmentToBuf(buf, i, spec, directory, mDirectory, &encDirectory, + useEncDirectory, &diff); + ShiftFromBasename(diff); + + // the directory must end with a '/' + if (buf[i - 1] != '/') { + buf[i++] = '/'; + mDirectory.mLen++; + } + + i = AppendSegmentToBuf(buf, i, spec, basename, mBasename, &encBasename, + useEncBasename, &diff); + ShiftFromExtension(diff); + + // make corrections to directory segment if leadingSlash + if (leadingSlash) { + mDirectory.mPos = mPath.mPos; + if (mDirectory.mLen >= 0) { + mDirectory.mLen += leadingSlash; + } else { + mDirectory.mLen = 1; + } + } + + if (mExtension.mLen >= 0) { + buf[i++] = '.'; + i = AppendSegmentToBuf(buf, i, spec, extension, mExtension, &encExtension, + useEncExtension, &diff); + ShiftFromQuery(diff); + } + // calculate corrected filepath length + mFilepath.mLen = i - mFilepath.mPos; + + if (mQuery.mLen >= 0) { + buf[i++] = '?'; + i = AppendSegmentToBuf(buf, i, spec, query, mQuery, &encQuery, + useEncQuery, &diff); + ShiftFromRef(diff); + } + if (mRef.mLen >= 0) { + buf[i++] = '#'; + i = AppendSegmentToBuf(buf, i, spec, ref, mRef, &encRef, useEncRef, + &diff); + } + // calculate corrected path length + mPath.mLen = i - mPath.mPos; + } + + buf[i] = '\0'; + + // https://url.spec.whatwg.org/#path-state (1.4.1.2) + // https://url.spec.whatwg.org/#windows-drive-letter + if (SegmentIs(buf, mScheme, "file")) { + char* path = &buf[mPath.mPos]; + if (mPath.mLen >= 3 && path[0] == '/' && IsAsciiAlpha(path[1]) && + path[2] == '|') { + buf[mPath.mPos + 2] = ':'; + } + } + + if (mDirectory.mLen > 1) { + netCoalesceFlags coalesceFlag = NET_COALESCE_NORMAL; + if (SegmentIs(buf, mScheme, "ftp")) { + coalesceFlag = + (netCoalesceFlags)(coalesceFlag | NET_COALESCE_ALLOW_RELATIVE_ROOT | + NET_COALESCE_DOUBLE_SLASH_IS_ROOT); + } + CoalescePath(coalesceFlag, buf + mDirectory.mPos); + } + mSpec.Truncate(strlen(buf)); + NS_ASSERTION(mSpec.Length() <= approxLen, + "We've overflowed the mSpec buffer!"); + MOZ_ASSERT(mSpec.Length() <= StaticPrefs::network_standard_url_max_length(), + "The spec should never be this long, we missed a check."); + + MOZ_ASSERT(mUsername.mLen != 0 && mPassword.mLen != 0); + return NS_OK; +} + +bool nsStandardURL::SegmentIs(const URLSegment& seg, const char* val, + bool ignoreCase) { + // one or both may be null + if (!val || mSpec.IsEmpty()) { + return (!val && (mSpec.IsEmpty() || seg.mLen < 0)); + } + if (seg.mLen < 0) { + return false; + } + // if the first |seg.mLen| chars of |val| match, then |val| must + // also be null terminated at |seg.mLen|. + if (ignoreCase) { + return !PL_strncasecmp(mSpec.get() + seg.mPos, val, seg.mLen) && + (val[seg.mLen] == '\0'); + } + + return !strncmp(mSpec.get() + seg.mPos, val, seg.mLen) && + (val[seg.mLen] == '\0'); +} + +bool nsStandardURL::SegmentIs(const char* spec, const URLSegment& seg, + const char* val, bool ignoreCase) { + // one or both may be null + if (!val || !spec) { + return (!val && (!spec || seg.mLen < 0)); + } + if (seg.mLen < 0) { + return false; + } + // if the first |seg.mLen| chars of |val| match, then |val| must + // also be null terminated at |seg.mLen|. + if (ignoreCase) { + return !PL_strncasecmp(spec + seg.mPos, val, seg.mLen) && + (val[seg.mLen] == '\0'); + } + + return !strncmp(spec + seg.mPos, val, seg.mLen) && (val[seg.mLen] == '\0'); +} + +bool nsStandardURL::SegmentIs(const URLSegment& seg1, const char* val, + const URLSegment& seg2, bool ignoreCase) { + if (seg1.mLen != seg2.mLen) { + return false; + } + if (seg1.mLen == -1 || (!val && mSpec.IsEmpty())) { + return true; // both are empty + } + if (!val) { + return false; + } + if (ignoreCase) { + return !PL_strncasecmp(mSpec.get() + seg1.mPos, val + seg2.mPos, seg1.mLen); + } + + return !strncmp(mSpec.get() + seg1.mPos, val + seg2.mPos, seg1.mLen); +} + +int32_t nsStandardURL::ReplaceSegment(uint32_t pos, uint32_t len, + const char* val, uint32_t valLen) { + if (val && valLen) { + if (len == 0) { + mSpec.Insert(val, pos, valLen); + } else { + mSpec.Replace(pos, len, nsDependentCString(val, valLen)); + } + return valLen - len; + } + + // else remove the specified segment + mSpec.Cut(pos, len); + return -int32_t(len); +} + +int32_t nsStandardURL::ReplaceSegment(uint32_t pos, uint32_t len, + const nsACString& val) { + if (len == 0) { + mSpec.Insert(val, pos); + } else { + mSpec.Replace(pos, len, val); + } + return val.Length() - len; +} + +nsresult nsStandardURL::ParseURL(const char* spec, int32_t specLen) { + nsresult rv; + + if (specLen > (int32_t)StaticPrefs::network_standard_url_max_length()) { + return NS_ERROR_MALFORMED_URI; + } + + // + // parse given URL string + // + rv = mParser->ParseURL(spec, specLen, &mScheme.mPos, &mScheme.mLen, + &mAuthority.mPos, &mAuthority.mLen, &mPath.mPos, + &mPath.mLen); + if (NS_FAILED(rv)) { + return rv; + } + +#ifdef DEBUG + if (mScheme.mLen <= 0) { + printf("spec=%s\n", spec); + NS_WARNING("malformed url: no scheme"); + } +#endif + + if (mAuthority.mLen > 0) { + rv = mParser->ParseAuthority(spec + mAuthority.mPos, mAuthority.mLen, + &mUsername.mPos, &mUsername.mLen, + &mPassword.mPos, &mPassword.mLen, &mHost.mPos, + &mHost.mLen, &mPort); + if (NS_FAILED(rv)) { + return rv; + } + + // Don't allow mPort to be set to this URI's default port + if (mPort == mDefaultPort) { + mPort = -1; + } + + mUsername.mPos += mAuthority.mPos; + mPassword.mPos += mAuthority.mPos; + mHost.mPos += mAuthority.mPos; + } + + if (mPath.mLen > 0) { + rv = ParsePath(spec, mPath.mPos, mPath.mLen); + } + + return rv; +} + +nsresult nsStandardURL::ParsePath(const char* spec, uint32_t pathPos, + int32_t pathLen) { + LOG(("ParsePath: %s pathpos %d len %d\n", spec, pathPos, pathLen)); + + if (pathLen > (int32_t)StaticPrefs::network_standard_url_max_length()) { + return NS_ERROR_MALFORMED_URI; + } + + nsresult rv = mParser->ParsePath(spec + pathPos, pathLen, &mFilepath.mPos, + &mFilepath.mLen, &mQuery.mPos, &mQuery.mLen, + &mRef.mPos, &mRef.mLen); + if (NS_FAILED(rv)) { + return rv; + } + + mFilepath.mPos += pathPos; + mQuery.mPos += pathPos; + mRef.mPos += pathPos; + + if (mFilepath.mLen > 0) { + rv = mParser->ParseFilePath(spec + mFilepath.mPos, mFilepath.mLen, + &mDirectory.mPos, &mDirectory.mLen, + &mBasename.mPos, &mBasename.mLen, + &mExtension.mPos, &mExtension.mLen); + if (NS_FAILED(rv)) { + return rv; + } + + mDirectory.mPos += mFilepath.mPos; + mBasename.mPos += mFilepath.mPos; + mExtension.mPos += mFilepath.mPos; + } + return NS_OK; +} + +char* nsStandardURL::AppendToSubstring(uint32_t pos, int32_t len, + const char* tail) { + // Verify pos and length are within boundaries + if (pos > mSpec.Length()) { + return nullptr; + } + if (len < 0) { + return nullptr; + } + if ((uint32_t)len > (mSpec.Length() - pos)) { + return nullptr; + } + if (!tail) { + return nullptr; + } + + uint32_t tailLen = strlen(tail); + + // Check for int overflow for proposed length of combined string + if (UINT32_MAX - ((uint32_t)len + 1) < tailLen) { + return nullptr; + } + + char* result = (char*)moz_xmalloc(len + tailLen + 1); + memcpy(result, mSpec.get() + pos, len); + memcpy(result + len, tail, tailLen); + result[len + tailLen] = '\0'; + return result; +} + +nsresult nsStandardURL::ReadSegment(nsIBinaryInputStream* stream, + URLSegment& seg) { + nsresult rv; + + rv = stream->Read32(&seg.mPos); + if (NS_FAILED(rv)) { + return rv; + } + + rv = stream->Read32((uint32_t*)&seg.mLen); + if (NS_FAILED(rv)) { + return rv; + } + + return NS_OK; +} + +nsresult nsStandardURL::WriteSegment(nsIBinaryOutputStream* stream, + const URLSegment& seg) { + nsresult rv; + + rv = stream->Write32(seg.mPos); + if (NS_FAILED(rv)) { + return rv; + } + + rv = stream->Write32(uint32_t(seg.mLen)); + if (NS_FAILED(rv)) { + return rv; + } + + return NS_OK; +} + +#define SHIFT_FROM(name, what) \ + void nsStandardURL::name(int32_t diff) { \ + if (!diff) return; \ + if ((what).mLen >= 0) { \ + CheckedInt<int32_t> pos = (what).mPos; \ + pos += diff; \ + MOZ_ASSERT(pos.isValid()); \ + (what).mPos = pos.value(); \ + } else { \ + MOZ_RELEASE_ASSERT((what).mLen == -1); \ + } + +#define SHIFT_FROM_NEXT(name, what, next) \ + SHIFT_FROM(name, what) \ + next(diff); \ + } + +#define SHIFT_FROM_LAST(name, what) \ + SHIFT_FROM(name, what) \ + } + +SHIFT_FROM_NEXT(ShiftFromAuthority, mAuthority, ShiftFromUsername) +SHIFT_FROM_NEXT(ShiftFromUsername, mUsername, ShiftFromPassword) +SHIFT_FROM_NEXT(ShiftFromPassword, mPassword, ShiftFromHost) +SHIFT_FROM_NEXT(ShiftFromHost, mHost, ShiftFromPath) +SHIFT_FROM_NEXT(ShiftFromPath, mPath, ShiftFromFilepath) +SHIFT_FROM_NEXT(ShiftFromFilepath, mFilepath, ShiftFromDirectory) +SHIFT_FROM_NEXT(ShiftFromDirectory, mDirectory, ShiftFromBasename) +SHIFT_FROM_NEXT(ShiftFromBasename, mBasename, ShiftFromExtension) +SHIFT_FROM_NEXT(ShiftFromExtension, mExtension, ShiftFromQuery) +SHIFT_FROM_NEXT(ShiftFromQuery, mQuery, ShiftFromRef) +SHIFT_FROM_LAST(ShiftFromRef, mRef) + +//---------------------------------------------------------------------------- +// nsStandardURL::nsIClassInfo +//---------------------------------------------------------------------------- + +NS_IMPL_CLASSINFO(nsStandardURL, nullptr, nsIClassInfo::THREADSAFE, + NS_STANDARDURL_CID) +// Empty CI getter. We only need nsIClassInfo for Serialization +NS_IMPL_CI_INTERFACE_GETTER0(nsStandardURL) + +//---------------------------------------------------------------------------- +// nsStandardURL::nsISupports +//---------------------------------------------------------------------------- + +NS_IMPL_ADDREF(nsStandardURL) +NS_IMPL_RELEASE(nsStandardURL) + +NS_INTERFACE_MAP_BEGIN(nsStandardURL) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIStandardURL) + NS_INTERFACE_MAP_ENTRY(nsIURI) + NS_INTERFACE_MAP_ENTRY(nsIURL) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIFileURL, mSupportsFileURL) + NS_INTERFACE_MAP_ENTRY(nsIStandardURL) + NS_INTERFACE_MAP_ENTRY(nsISerializable) + NS_IMPL_QUERY_CLASSINFO(nsStandardURL) + NS_INTERFACE_MAP_ENTRY(nsISensitiveInfoHiddenURI) + // see nsStandardURL::Equals + if (aIID.Equals(kThisImplCID)) { + foundInterface = static_cast<nsIURI*>(this); + } else + NS_INTERFACE_MAP_ENTRY(nsISizeOf) +NS_INTERFACE_MAP_END + +//---------------------------------------------------------------------------- +// nsStandardURL::nsIURI +//---------------------------------------------------------------------------- + +// result may contain unescaped UTF-8 characters +NS_IMETHODIMP +nsStandardURL::GetSpec(nsACString& result) { + MOZ_ASSERT(mSpec.Length() <= StaticPrefs::network_standard_url_max_length(), + "The spec should never be this long, we missed a check."); + result = mSpec; + return NS_OK; +} + +// result may contain unescaped UTF-8 characters +NS_IMETHODIMP +nsStandardURL::GetSensitiveInfoHiddenSpec(nsACString& result) { + nsresult rv = GetSpec(result); + if (NS_FAILED(rv)) { + return rv; + } + if (mPassword.mLen > 0) { + result.ReplaceLiteral(mPassword.mPos, mPassword.mLen, "****"); + } + return NS_OK; +} + +// result may contain unescaped UTF-8 characters +NS_IMETHODIMP +nsStandardURL::GetSpecIgnoringRef(nsACString& result) { + // URI without ref is 0 to one char before ref + if (mRef.mLen < 0) { + return GetSpec(result); + } + + URLSegment noRef(0, mRef.mPos - 1); + result = Segment(noRef); + MOZ_ASSERT(mCheckedIfHostA); + return NS_OK; +} + +nsresult nsStandardURL::CheckIfHostIsAscii() { + nsresult rv; + if (mCheckedIfHostA) { + return NS_OK; + } + + mCheckedIfHostA = true; + + if (!gIDN) { + return NS_ERROR_NOT_INITIALIZED; + } + + nsAutoCString displayHost; + bool isAscii; + rv = gIDN->ConvertToDisplayIDN(Host(), &isAscii, displayHost); + if (NS_FAILED(rv)) { + mDisplayHost.Truncate(); + mCheckedIfHostA = false; + return rv; + } + + if (!isAscii) { + mDisplayHost = displayHost; + } + + return NS_OK; +} + +NS_IMETHODIMP +nsStandardURL::GetDisplaySpec(nsACString& aUnicodeSpec) { + aUnicodeSpec.Assign(mSpec); + MOZ_ASSERT(mCheckedIfHostA); + if (!mDisplayHost.IsEmpty()) { + aUnicodeSpec.Replace(mHost.mPos, mHost.mLen, mDisplayHost); + } + + return NS_OK; +} + +NS_IMETHODIMP +nsStandardURL::GetDisplayHostPort(nsACString& aUnicodeHostPort) { + nsAutoCString unicodeHostPort; + + nsresult rv = GetDisplayHost(unicodeHostPort); + if (NS_FAILED(rv)) { + return rv; + } + + if (StringBeginsWith(Hostport(), "["_ns)) { + aUnicodeHostPort.AssignLiteral("["); + aUnicodeHostPort.Append(unicodeHostPort); + aUnicodeHostPort.AppendLiteral("]"); + } else { + aUnicodeHostPort.Assign(unicodeHostPort); + } + + uint32_t pos = mHost.mPos + mHost.mLen; + if (pos < mPath.mPos) { + aUnicodeHostPort += Substring(mSpec, pos, mPath.mPos - pos); + } + + return NS_OK; +} + +NS_IMETHODIMP +nsStandardURL::GetDisplayHost(nsACString& aUnicodeHost) { + MOZ_ASSERT(mCheckedIfHostA); + if (mDisplayHost.IsEmpty()) { + return GetAsciiHost(aUnicodeHost); + } + + aUnicodeHost = mDisplayHost; + return NS_OK; +} + +// result may contain unescaped UTF-8 characters +NS_IMETHODIMP +nsStandardURL::GetPrePath(nsACString& result) { + result = Prepath(); + MOZ_ASSERT(mCheckedIfHostA); + return NS_OK; +} + +// result may contain unescaped UTF-8 characters +NS_IMETHODIMP +nsStandardURL::GetDisplayPrePath(nsACString& result) { + result = Prepath(); + MOZ_ASSERT(mCheckedIfHostA); + if (!mDisplayHost.IsEmpty()) { + result.Replace(mHost.mPos, mHost.mLen, mDisplayHost); + } + return NS_OK; +} + +// result is strictly US-ASCII +NS_IMETHODIMP +nsStandardURL::GetScheme(nsACString& result) { + result = Scheme(); + return NS_OK; +} + +// result may contain unescaped UTF-8 characters +NS_IMETHODIMP +nsStandardURL::GetUserPass(nsACString& result) { + result = Userpass(); + return NS_OK; +} + +// result may contain unescaped UTF-8 characters +NS_IMETHODIMP +nsStandardURL::GetUsername(nsACString& result) { + result = Username(); + return NS_OK; +} + +// result may contain unescaped UTF-8 characters +NS_IMETHODIMP +nsStandardURL::GetPassword(nsACString& result) { + result = Password(); + return NS_OK; +} + +NS_IMETHODIMP +nsStandardURL::GetHostPort(nsACString& result) { + return GetAsciiHostPort(result); +} + +NS_IMETHODIMP +nsStandardURL::GetHost(nsACString& result) { return GetAsciiHost(result); } + +NS_IMETHODIMP +nsStandardURL::GetPort(int32_t* result) { + // should never be more than 16 bit + MOZ_ASSERT(mPort <= std::numeric_limits<uint16_t>::max()); + *result = mPort; + return NS_OK; +} + +// result may contain unescaped UTF-8 characters +NS_IMETHODIMP +nsStandardURL::GetPathQueryRef(nsACString& result) { + result = Path(); + return NS_OK; +} + +// result is ASCII +NS_IMETHODIMP +nsStandardURL::GetAsciiSpec(nsACString& result) { + result = mSpec; + return NS_OK; +} + +// result is ASCII +NS_IMETHODIMP +nsStandardURL::GetAsciiHostPort(nsACString& result) { + result = Hostport(); + return NS_OK; +} + +// result is ASCII +NS_IMETHODIMP +nsStandardURL::GetAsciiHost(nsACString& result) { + result = Host(); + return NS_OK; +} + +static bool IsSpecialProtocol(const nsACString& input) { + nsACString::const_iterator start, end; + input.BeginReading(start); + nsACString::const_iterator iterator(start); + input.EndReading(end); + + while (iterator != end && *iterator != ':') { + iterator++; + } + + nsAutoCString protocol(nsDependentCSubstring(start.get(), iterator.get())); + + return protocol.LowerCaseEqualsLiteral("http") || + protocol.LowerCaseEqualsLiteral("https") || + protocol.LowerCaseEqualsLiteral("ftp") || + protocol.LowerCaseEqualsLiteral("ws") || + protocol.LowerCaseEqualsLiteral("wss") || + protocol.LowerCaseEqualsLiteral("file") || + protocol.LowerCaseEqualsLiteral("gopher"); +} + +nsresult nsStandardURL::SetSpecInternal(const nsACString& input) { + return SetSpecWithEncoding(input, nullptr); +} + +nsresult nsStandardURL::SetSpecWithEncoding(const nsACString& input, + const Encoding* encoding) { + const nsPromiseFlatCString& flat = PromiseFlatCString(input); + LOG(("nsStandardURL::SetSpec [spec=%s]\n", flat.get())); + + if (input.Length() > StaticPrefs::network_standard_url_max_length()) { + return NS_ERROR_MALFORMED_URI; + } + + // filter out unexpected chars "\r\n\t" if necessary + nsAutoCString filteredURI; + net_FilterURIString(flat, filteredURI); + + if (filteredURI.Length() == 0) { + return NS_ERROR_MALFORMED_URI; + } + + // Make a backup of the current URL + nsStandardURL prevURL(false, false); + prevURL.CopyMembers(this, eHonorRef, ""_ns); + Clear(); + + if (IsSpecialProtocol(filteredURI)) { + // Bug 652186: Replace all backslashes with slashes when parsing paths + // Stop when we reach the query or the hash. + auto* start = filteredURI.BeginWriting(); + auto* end = filteredURI.EndWriting(); + while (start != end) { + if (*start == '?' || *start == '#') { + break; + } + if (*start == '\\') { + *start = '/'; + } + start++; + } + } + + const char* spec = filteredURI.get(); + int32_t specLength = filteredURI.Length(); + + // parse the given URL... + nsresult rv = ParseURL(spec, specLength); + if (mScheme.mLen <= 0) { + rv = NS_ERROR_MALFORMED_URI; + } + if (NS_SUCCEEDED(rv)) { + // finally, use the URLSegment member variables to build a normalized + // copy of |spec| + rv = BuildNormalizedSpec(spec, encoding); + } + + // Make sure that a URLTYPE_AUTHORITY has a non-empty hostname. + if (mURLType == URLTYPE_AUTHORITY && mHost.mLen == -1) { + rv = NS_ERROR_MALFORMED_URI; + } + + if (NS_FAILED(rv)) { + Clear(); + // If parsing the spec has failed, restore the old URL + // so we don't end up with an empty URL. + CopyMembers(&prevURL, eHonorRef, ""_ns); + return rv; + } + + if (LOG_ENABLED()) { + LOG((" spec = %s\n", mSpec.get())); + LOG((" port = %d\n", mPort)); + LOG((" scheme = (%u,%d)\n", mScheme.mPos, mScheme.mLen)); + LOG((" authority = (%u,%d)\n", mAuthority.mPos, mAuthority.mLen)); + LOG((" username = (%u,%d)\n", mUsername.mPos, mUsername.mLen)); + LOG((" password = (%u,%d)\n", mPassword.mPos, mPassword.mLen)); + LOG((" hostname = (%u,%d)\n", mHost.mPos, mHost.mLen)); + LOG((" path = (%u,%d)\n", mPath.mPos, mPath.mLen)); + LOG((" filepath = (%u,%d)\n", mFilepath.mPos, mFilepath.mLen)); + LOG((" directory = (%u,%d)\n", mDirectory.mPos, mDirectory.mLen)); + LOG((" basename = (%u,%d)\n", mBasename.mPos, mBasename.mLen)); + LOG((" extension = (%u,%d)\n", mExtension.mPos, mExtension.mLen)); + LOG((" query = (%u,%d)\n", mQuery.mPos, mQuery.mLen)); + LOG((" ref = (%u,%d)\n", mRef.mPos, mRef.mLen)); + } + + return rv; +} + +nsresult nsStandardURL::SetScheme(const nsACString& input) { + const nsPromiseFlatCString& scheme = PromiseFlatCString(input); + + LOG(("nsStandardURL::SetScheme [scheme=%s]\n", scheme.get())); + + if (scheme.IsEmpty()) { + NS_WARNING("cannot remove the scheme from an url"); + return NS_ERROR_UNEXPECTED; + } + if (mScheme.mLen < 0) { + NS_WARNING("uninitialized"); + return NS_ERROR_NOT_INITIALIZED; + } + + if (!net_IsValidScheme(scheme)) { + NS_WARNING("the given url scheme contains invalid characters"); + return NS_ERROR_UNEXPECTED; + } + + if (mSpec.Length() + input.Length() - Scheme().Length() > + StaticPrefs::network_standard_url_max_length()) { + return NS_ERROR_MALFORMED_URI; + } + + InvalidateCache(); + + int32_t shift = ReplaceSegment(mScheme.mPos, mScheme.mLen, scheme); + + if (shift) { + mScheme.mLen = scheme.Length(); + ShiftFromAuthority(shift); + } + + // ensure new scheme is lowercase + // + // XXX the string code unfortunately doesn't provide a ToLowerCase + // that operates on a substring. + net_ToLowerCase((char*)mSpec.get(), mScheme.mLen); + return NS_OK; +} + +nsresult nsStandardURL::SetUserPass(const nsACString& input) { + const nsPromiseFlatCString& userpass = PromiseFlatCString(input); + + LOG(("nsStandardURL::SetUserPass [userpass=%s]\n", userpass.get())); + + if (mURLType == URLTYPE_NO_AUTHORITY) { + if (userpass.IsEmpty()) { + return NS_OK; + } + NS_WARNING("cannot set user:pass on no-auth url"); + return NS_ERROR_UNEXPECTED; + } + if (mAuthority.mLen < 0) { + NS_WARNING("uninitialized"); + return NS_ERROR_NOT_INITIALIZED; + } + + if (mSpec.Length() + input.Length() - Userpass(true).Length() > + StaticPrefs::network_standard_url_max_length()) { + return NS_ERROR_MALFORMED_URI; + } + + InvalidateCache(); + + NS_ASSERTION(mHost.mLen >= 0, "uninitialized"); + + nsresult rv; + uint32_t usernamePos, passwordPos; + int32_t usernameLen, passwordLen; + + rv = mParser->ParseUserInfo(userpass.get(), userpass.Length(), &usernamePos, + &usernameLen, &passwordPos, &passwordLen); + if (NS_FAILED(rv)) { + return rv; + } + + // build new user:pass in |buf| + nsAutoCString buf; + if (usernameLen > 0 || passwordLen > 0) { + nsSegmentEncoder encoder; + bool ignoredOut; + usernameLen = encoder.EncodeSegmentCount( + userpass.get(), URLSegment(usernamePos, usernameLen), + esc_Username | esc_AlwaysCopy, buf, ignoredOut); + if (passwordLen > 0) { + buf.Append(':'); + passwordLen = encoder.EncodeSegmentCount( + userpass.get(), URLSegment(passwordPos, passwordLen), + esc_Password | esc_AlwaysCopy, buf, ignoredOut); + } else { + passwordLen = -1; + } + if (mUsername.mLen < 0 && mPassword.mLen < 0) { + buf.Append('@'); + } + } + + int32_t shift = 0; + + if (mUsername.mLen < 0 && mPassword.mLen < 0) { + // no existing user:pass + if (!buf.IsEmpty()) { + mSpec.Insert(buf, mHost.mPos); + mUsername.mPos = mHost.mPos; + shift = buf.Length(); + } + } else { + // replace existing user:pass + uint32_t userpassLen = 0; + if (mUsername.mLen > 0) { + userpassLen += mUsername.mLen; + } + if (mPassword.mLen > 0) { + userpassLen += (mPassword.mLen + 1); + } + if (buf.IsEmpty()) { + // remove `@` character too + userpassLen++; + } + mSpec.Replace(mAuthority.mPos, userpassLen, buf); + shift = buf.Length() - userpassLen; + } + if (shift) { + ShiftFromHost(shift); + MOZ_DIAGNOSTIC_ASSERT(mAuthority.mLen >= -shift); + mAuthority.mLen += shift; + } + // update positions and lengths + mUsername.mLen = usernameLen > 0 ? usernameLen : -1; + mUsername.mPos = mAuthority.mPos; + mPassword.mLen = passwordLen > 0 ? passwordLen : -1; + if (passwordLen > 0) { + if (mUsername.mLen > 0) { + mPassword.mPos = mUsername.mPos + mUsername.mLen + 1; + } else { + mPassword.mPos = mAuthority.mPos + 1; + } + } + + MOZ_ASSERT(mUsername.mLen != 0 && mPassword.mLen != 0); + return NS_OK; +} + +nsresult nsStandardURL::SetUsername(const nsACString& input) { + const nsPromiseFlatCString& username = PromiseFlatCString(input); + + LOG(("nsStandardURL::SetUsername [username=%s]\n", username.get())); + + if (mURLType == URLTYPE_NO_AUTHORITY) { + if (username.IsEmpty()) { + return NS_OK; + } + NS_WARNING("cannot set username on no-auth url"); + return NS_ERROR_UNEXPECTED; + } + + if (mSpec.Length() + input.Length() - Username().Length() > + StaticPrefs::network_standard_url_max_length()) { + return NS_ERROR_MALFORMED_URI; + } + + InvalidateCache(); + + // escape username if necessary + nsAutoCString buf; + nsSegmentEncoder encoder; + const nsACString& escUsername = + encoder.EncodeSegment(username, esc_Username, buf); + + int32_t shift = 0; + + if (mUsername.mLen < 0 && escUsername.IsEmpty()) { + return NS_OK; + } + + if (mUsername.mLen < 0 && mPassword.mLen < 0) { + MOZ_ASSERT(!escUsername.IsEmpty(), "Should not be empty at this point"); + mUsername.mPos = mAuthority.mPos; + mSpec.Insert(escUsername + "@"_ns, mUsername.mPos); + shift = escUsername.Length() + 1; + mUsername.mLen = escUsername.Length() > 0 ? escUsername.Length() : -1; + } else { + uint32_t pos = mUsername.mLen < 0 ? mAuthority.mPos : mUsername.mPos; + int32_t len = mUsername.mLen < 0 ? 0 : mUsername.mLen; + + if (mPassword.mLen < 0 && escUsername.IsEmpty()) { + len++; // remove the @ character too + } + shift = ReplaceSegment(pos, len, escUsername); + mUsername.mLen = escUsername.Length() > 0 ? escUsername.Length() : -1; + mUsername.mPos = pos; + } + + if (shift) { + mAuthority.mLen += shift; + ShiftFromPassword(shift); + } + + MOZ_ASSERT(mUsername.mLen != 0 && mPassword.mLen != 0); + return NS_OK; +} + +nsresult nsStandardURL::SetPassword(const nsACString& input) { + const nsPromiseFlatCString& password = PromiseFlatCString(input); + + auto clearedPassword = MakeScopeExit([&password, this]() { + // Check that if this method is called with the empty string then the + // password is definitely cleared when exiting this method. + if (password.IsEmpty()) { + MOZ_DIAGNOSTIC_ASSERT(this->Password().IsEmpty()); + } + Unused << this; // silence compiler -Wunused-lambda-capture + }); + + LOG(("nsStandardURL::SetPassword [password=%s]\n", password.get())); + + if (mURLType == URLTYPE_NO_AUTHORITY) { + if (password.IsEmpty()) { + return NS_OK; + } + NS_WARNING("cannot set password on no-auth url"); + return NS_ERROR_UNEXPECTED; + } + + if (mSpec.Length() + input.Length() - Password().Length() > + StaticPrefs::network_standard_url_max_length()) { + return NS_ERROR_MALFORMED_URI; + } + + InvalidateCache(); + + if (password.IsEmpty()) { + if (mPassword.mLen > 0) { + // cut(":password") + int32_t len = mPassword.mLen; + if (mUsername.mLen < 0) { + len++; // also cut the @ character + } + len++; // for the : character + mSpec.Cut(mPassword.mPos - 1, len); + ShiftFromHost(-len); + mAuthority.mLen -= len; + mPassword.mLen = -1; + } + MOZ_ASSERT(mUsername.mLen != 0 && mPassword.mLen != 0); + return NS_OK; + } + + // escape password if necessary + nsAutoCString buf; + nsSegmentEncoder encoder; + const nsACString& escPassword = + encoder.EncodeSegment(password, esc_Password, buf); + + int32_t shift; + + if (mPassword.mLen < 0) { + if (mUsername.mLen > 0) { + mPassword.mPos = mUsername.mPos + mUsername.mLen + 1; + mSpec.Insert(":"_ns + escPassword, mPassword.mPos - 1); + shift = escPassword.Length() + 1; + } else { + mPassword.mPos = mAuthority.mPos + 1; + mSpec.Insert(":"_ns + escPassword + "@"_ns, mPassword.mPos - 1); + shift = escPassword.Length() + 2; + } + } else { + shift = ReplaceSegment(mPassword.mPos, mPassword.mLen, escPassword); + } + + if (shift) { + mPassword.mLen = escPassword.Length(); + mAuthority.mLen += shift; + ShiftFromHost(shift); + } + + MOZ_ASSERT(mUsername.mLen != 0 && mPassword.mLen != 0); + return NS_OK; +} + +void nsStandardURL::FindHostLimit(nsACString::const_iterator& aStart, + nsACString::const_iterator& aEnd) { + for (int32_t i = 0; gHostLimitDigits[i]; ++i) { + nsACString::const_iterator c(aStart); + if (FindCharInReadable(gHostLimitDigits[i], c, aEnd)) { + aEnd = c; + } + } +} + +// If aValue only has a host part and no port number, the port +// will not be reset!!! +nsresult nsStandardURL::SetHostPort(const nsACString& aValue) { + // We cannot simply call nsIURI::SetHost because that would treat the name as + // an IPv6 address (like http:://[server:443]/). We also cannot call + // nsIURI::SetHostPort because that isn't implemented. Sadfaces. + + nsACString::const_iterator start, end; + aValue.BeginReading(start); + aValue.EndReading(end); + nsACString::const_iterator iter(start); + bool isIPv6 = false; + + FindHostLimit(start, end); + + if (*start == '[') { // IPv6 address + if (!FindCharInReadable(']', iter, end)) { + // the ] character is missing + return NS_ERROR_MALFORMED_URI; + } + // iter now at the ']' character + isIPv6 = true; + } else { + nsACString::const_iterator iter2(start); + if (FindCharInReadable(']', iter2, end)) { + // if the first char isn't [ then there should be no ] character + return NS_ERROR_MALFORMED_URI; + } + } + + FindCharInReadable(':', iter, end); + + if (!isIPv6 && iter != end) { + nsACString::const_iterator iter2(iter); + iter2++; // Skip over the first ':' character + if (FindCharInReadable(':', iter2, end)) { + // If there is more than one ':' character it suggests an IPv6 + // The format should be [2001::1]:80 where the port is optional + return NS_ERROR_MALFORMED_URI; + } + } + + nsresult rv = SetHost(Substring(start, iter)); + NS_ENSURE_SUCCESS(rv, rv); + + if (iter == end) { + // does not end in colon + return NS_OK; + } + + iter++; // advance over the colon + if (iter == end) { + // port number is missing + return NS_OK; + } + + nsCString portStr(Substring(iter, end)); + int32_t port = portStr.ToInteger(&rv); + if (NS_FAILED(rv)) { + // Failure parsing the port number + return NS_OK; + } + + Unused << SetPort(port); + return NS_OK; +} + +nsresult nsStandardURL::SetHost(const nsACString& input) { + const nsPromiseFlatCString& hostname = PromiseFlatCString(input); + + nsACString::const_iterator start, end; + hostname.BeginReading(start); + hostname.EndReading(end); + + FindHostLimit(start, end); + + const nsCString unescapedHost(Substring(start, end)); + // Do percent decoding on the the input. + nsAutoCString flat; + NS_UnescapeURL(unescapedHost.BeginReading(), unescapedHost.Length(), + esc_AlwaysCopy | esc_Host, flat); + const char* host = flat.get(); + + LOG(("nsStandardURL::SetHost [host=%s]\n", host)); + + if (mURLType == URLTYPE_NO_AUTHORITY) { + if (flat.IsEmpty()) { + return NS_OK; + } + NS_WARNING("cannot set host on no-auth url"); + return NS_ERROR_UNEXPECTED; + } + if (flat.IsEmpty()) { + // Setting an empty hostname is not allowed for + // URLTYPE_STANDARD and URLTYPE_AUTHORITY. + return NS_ERROR_UNEXPECTED; + } + + if (strlen(host) < flat.Length()) { + return NS_ERROR_MALFORMED_URI; // found embedded null + } + + // For consistency with SetSpec/nsURLParsers, don't allow spaces + // in the hostname. + if (strchr(host, ' ')) { + return NS_ERROR_MALFORMED_URI; + } + + if (mSpec.Length() + strlen(host) - Host().Length() > + StaticPrefs::network_standard_url_max_length()) { + return NS_ERROR_MALFORMED_URI; + } + + InvalidateCache(); + + uint32_t len; + nsAutoCString hostBuf; + nsresult rv = NormalizeIDN(flat, hostBuf); + if (NS_FAILED(rv)) { + return rv; + } + + if (!SegmentIs(mScheme, "resource") && !SegmentIs(mScheme, "chrome")) { + nsAutoCString ipString; + if (hostBuf.Length() > 0 && hostBuf.First() == '[' && + hostBuf.Last() == ']' && + ValidIPv6orHostname(hostBuf.get(), hostBuf.Length())) { + rv = (nsresult)rusturl_parse_ipv6addr(&hostBuf, &ipString); + if (NS_FAILED(rv)) { + return rv; + } + hostBuf = ipString; + } else if (NS_SUCCEEDED(NormalizeIPv4(hostBuf, ipString))) { + hostBuf = ipString; + } + } + + // NormalizeIDN always copies if the call was successful + host = hostBuf.get(); + len = hostBuf.Length(); + + if (!ValidIPv6orHostname(host, len)) { + return NS_ERROR_MALFORMED_URI; + } + + if (mHost.mLen < 0) { + int port_length = 0; + if (mPort != -1) { + nsAutoCString buf; + buf.Assign(':'); + buf.AppendInt(mPort); + port_length = buf.Length(); + } + if (mAuthority.mLen > 0) { + mHost.mPos = mAuthority.mPos + mAuthority.mLen - port_length; + mHost.mLen = 0; + } else if (mScheme.mLen > 0) { + mHost.mPos = mScheme.mPos + mScheme.mLen + 3; + mHost.mLen = 0; + } + } + + int32_t shift = ReplaceSegment(mHost.mPos, mHost.mLen, host, len); + + if (shift) { + mHost.mLen = len; + mAuthority.mLen += shift; + ShiftFromPath(shift); + } + + // Now canonicalize the host to lowercase + net_ToLowerCase(mSpec.BeginWriting() + mHost.mPos, mHost.mLen); + return NS_OK; +} + +nsresult nsStandardURL::SetPort(int32_t port) { + LOG(("nsStandardURL::SetPort [port=%d]\n", port)); + + if ((port == mPort) || (mPort == -1 && port == mDefaultPort)) { + return NS_OK; + } + + // ports must be >= 0 and 16 bit + // -1 == use default + if (port < -1 || port > std::numeric_limits<uint16_t>::max()) { + return NS_ERROR_MALFORMED_URI; + } + + if (mURLType == URLTYPE_NO_AUTHORITY) { + NS_WARNING("cannot set port on no-auth url"); + return NS_ERROR_UNEXPECTED; + } + + InvalidateCache(); + if (port == mDefaultPort) { + port = -1; + } + + ReplacePortInSpec(port); + + mPort = port; + return NS_OK; +} + +/** + * Replaces the existing port in mSpec with aNewPort. + * + * The caller is responsible for: + * - Calling InvalidateCache (since our mSpec is changing). + * - Checking whether aNewPort is mDefaultPort (in which case the + * caller should pass aNewPort=-1). + */ +void nsStandardURL::ReplacePortInSpec(int32_t aNewPort) { + NS_ASSERTION(aNewPort != mDefaultPort || mDefaultPort == -1, + "Caller should check its passed-in value and pass -1 instead of " + "mDefaultPort, to avoid encoding default port into mSpec"); + + // Create the (possibly empty) string that we're planning to replace: + nsAutoCString buf; + if (mPort != -1) { + buf.Assign(':'); + buf.AppendInt(mPort); + } + // Find the position & length of that string: + const uint32_t replacedLen = buf.Length(); + const uint32_t replacedStart = + mAuthority.mPos + mAuthority.mLen - replacedLen; + + // Create the (possibly empty) replacement string: + if (aNewPort == -1) { + buf.Truncate(); + } else { + buf.Assign(':'); + buf.AppendInt(aNewPort); + } + // Perform the replacement: + mSpec.Replace(replacedStart, replacedLen, buf); + + // Bookkeeping to reflect the new length: + int32_t shift = buf.Length() - replacedLen; + mAuthority.mLen += shift; + ShiftFromPath(shift); +} + +nsresult nsStandardURL::SetPathQueryRef(const nsACString& input) { + const nsPromiseFlatCString& path = PromiseFlatCString(input); + LOG(("nsStandardURL::SetPathQueryRef [path=%s]\n", path.get())); + + InvalidateCache(); + + if (!path.IsEmpty()) { + nsAutoCString spec; + + spec.Assign(mSpec.get(), mPath.mPos); + if (path.First() != '/') { + spec.Append('/'); + } + spec.Append(path); + + return SetSpecInternal(spec); + } + if (mPath.mLen >= 1) { + mSpec.Cut(mPath.mPos + 1, mPath.mLen - 1); + // these contain only a '/' + mPath.mLen = 1; + mDirectory.mLen = 1; + mFilepath.mLen = 1; + // these are no longer defined + mBasename.mLen = -1; + mExtension.mLen = -1; + mQuery.mLen = -1; + mRef.mLen = -1; + } + return NS_OK; +} + +// When updating this also update SubstitutingURL::Mutator +// Queries this list of interfaces. If none match, it queries mURI. +NS_IMPL_NSIURIMUTATOR_ISUPPORTS(nsStandardURL::Mutator, nsIURISetters, + nsIURIMutator, nsIStandardURLMutator, + nsIURLMutator, nsIFileURLMutator, + nsISerializable) + +NS_IMETHODIMP +nsStandardURL::Mutate(nsIURIMutator** aMutator) { + RefPtr<nsStandardURL::Mutator> mutator = new nsStandardURL::Mutator(); + nsresult rv = mutator->InitFromURI(this); + if (NS_FAILED(rv)) { + return rv; + } + mutator.forget(aMutator); + return NS_OK; +} + +NS_IMETHODIMP +nsStandardURL::Equals(nsIURI* unknownOther, bool* result) { + return EqualsInternal(unknownOther, eHonorRef, result); +} + +NS_IMETHODIMP +nsStandardURL::EqualsExceptRef(nsIURI* unknownOther, bool* result) { + return EqualsInternal(unknownOther, eIgnoreRef, result); +} + +nsresult nsStandardURL::EqualsInternal( + nsIURI* unknownOther, nsStandardURL::RefHandlingEnum refHandlingMode, + bool* result) { + NS_ENSURE_ARG_POINTER(unknownOther); + MOZ_ASSERT(result, "null pointer"); + + RefPtr<nsStandardURL> other; + nsresult rv = + unknownOther->QueryInterface(kThisImplCID, getter_AddRefs(other)); + if (NS_FAILED(rv)) { + *result = false; + return NS_OK; + } + + // First, check whether one URIs is an nsIFileURL while the other + // is not. If that's the case, they're different. + if (mSupportsFileURL != other->mSupportsFileURL) { + *result = false; + return NS_OK; + } + + // Next check parts of a URI that, if different, automatically make the + // URIs different + if (!SegmentIs(mScheme, other->mSpec.get(), other->mScheme) || + // Check for host manually, since conversion to file will + // ignore the host! + !SegmentIs(mHost, other->mSpec.get(), other->mHost) || + !SegmentIs(mQuery, other->mSpec.get(), other->mQuery) || + !SegmentIs(mUsername, other->mSpec.get(), other->mUsername) || + !SegmentIs(mPassword, other->mSpec.get(), other->mPassword) || + Port() != other->Port()) { + // No need to compare files or other URI parts -- these are different + // beasties + *result = false; + return NS_OK; + } + + if (refHandlingMode == eHonorRef && + !SegmentIs(mRef, other->mSpec.get(), other->mRef)) { + *result = false; + return NS_OK; + } + + // Then check for exact identity of URIs. If we have it, they're equal + if (SegmentIs(mDirectory, other->mSpec.get(), other->mDirectory) && + SegmentIs(mBasename, other->mSpec.get(), other->mBasename) && + SegmentIs(mExtension, other->mSpec.get(), other->mExtension)) { + *result = true; + return NS_OK; + } + + // At this point, the URIs are not identical, but they only differ in the + // directory/filename/extension. If these are file URLs, then get the + // corresponding file objects and compare those, since two filenames that + // differ, eg, only in case could still be equal. + if (mSupportsFileURL) { + // Assume not equal for failure cases... but failures in GetFile are + // really failures, more or less, so propagate them to caller. + *result = false; + + rv = EnsureFile(); + nsresult rv2 = other->EnsureFile(); + // special case for resource:// urls that don't resolve to files + if (rv == NS_ERROR_NO_INTERFACE && rv == rv2) { + return NS_OK; + } + + if (NS_FAILED(rv)) { + LOG(("nsStandardURL::Equals [this=%p spec=%s] failed to ensure file", + this, mSpec.get())); + return rv; + } + NS_ASSERTION(mFile, "EnsureFile() lied!"); + rv = rv2; + if (NS_FAILED(rv)) { + LOG( + ("nsStandardURL::Equals [other=%p spec=%s] other failed to ensure " + "file", + other.get(), other->mSpec.get())); + return rv; + } + NS_ASSERTION(other->mFile, "EnsureFile() lied!"); + return mFile->Equals(other->mFile, result); + } + + // The URLs are not identical, and they do not correspond to the + // same file, so they are different. + *result = false; + + return NS_OK; +} + +NS_IMETHODIMP +nsStandardURL::SchemeIs(const char* scheme, bool* result) { + MOZ_ASSERT(result, "null pointer"); + if (!scheme) { + *result = false; + return NS_OK; + } + + *result = SegmentIs(mScheme, scheme); + return NS_OK; +} + +/* virtual */ nsStandardURL* nsStandardURL::StartClone() { + nsStandardURL* clone = new nsStandardURL(); + return clone; +} + +nsresult nsStandardURL::Clone(nsIURI** aURI) { + return CloneInternal(eHonorRef, ""_ns, aURI); +} + +nsresult nsStandardURL::CloneInternal( + nsStandardURL::RefHandlingEnum aRefHandlingMode, const nsACString& aNewRef, + nsIURI** aClone) + +{ + RefPtr<nsStandardURL> clone = StartClone(); + if (!clone) { + return NS_ERROR_OUT_OF_MEMORY; + } + + // Copy local members into clone. + // Also copies the cached members mFile, mDisplayHost + clone->CopyMembers(this, aRefHandlingMode, aNewRef, true); + + clone.forget(aClone); + return NS_OK; +} + +nsresult nsStandardURL::CopyMembers( + nsStandardURL* source, nsStandardURL::RefHandlingEnum refHandlingMode, + const nsACString& newRef, bool copyCached) { + mSpec = source->mSpec; + mDefaultPort = source->mDefaultPort; + mPort = source->mPort; + mScheme = source->mScheme; + mAuthority = source->mAuthority; + mUsername = source->mUsername; + mPassword = source->mPassword; + mHost = source->mHost; + mPath = source->mPath; + mFilepath = source->mFilepath; + mDirectory = source->mDirectory; + mBasename = source->mBasename; + mExtension = source->mExtension; + mQuery = source->mQuery; + mRef = source->mRef; + mURLType = source->mURLType; + mParser = source->mParser; + mSupportsFileURL = source->mSupportsFileURL; + mCheckedIfHostA = source->mCheckedIfHostA; + mDisplayHost = source->mDisplayHost; + + if (copyCached) { + mFile = source->mFile; + } else { + InvalidateCache(true); + } + + if (refHandlingMode == eIgnoreRef) { + SetRef(""_ns); + } else if (refHandlingMode == eReplaceRef) { + SetRef(newRef); + } + + return NS_OK; +} + +NS_IMETHODIMP +nsStandardURL::Resolve(const nsACString& in, nsACString& out) { + const nsPromiseFlatCString& flat = PromiseFlatCString(in); + // filter out unexpected chars "\r\n\t" if necessary + nsAutoCString buf; + net_FilterURIString(flat, buf); + + const char* relpath = buf.get(); + int32_t relpathLen = buf.Length(); + + char* result = nullptr; + + LOG(("nsStandardURL::Resolve [this=%p spec=%s relpath=%s]\n", this, + mSpec.get(), relpath)); + + NS_ASSERTION(mParser, "no parser: unitialized"); + + // NOTE: there is no need for this function to produce normalized + // output. normalization will occur when the result is used to + // initialize a nsStandardURL object. + + if (mScheme.mLen < 0) { + NS_WARNING("unable to Resolve URL: this URL not initialized"); + return NS_ERROR_NOT_INITIALIZED; + } + + nsresult rv; + URLSegment scheme; + char* resultPath = nullptr; + bool relative = false; + uint32_t offset = 0; + netCoalesceFlags coalesceFlag = NET_COALESCE_NORMAL; + + nsAutoCString baseProtocol(Scheme()); + nsAutoCString protocol; + rv = net_ExtractURLScheme(buf, protocol); + + // Normally, if we parse a scheme, then it's an absolute URI. But because + // we still support a deprecated form of relative URIs such as: http:file or + // http:/path/file we can't do that for all protocols. + // So we just make sure that if there a protocol, it's the same as the + // current one, otherwise we treat it as an absolute URI. + if (NS_SUCCEEDED(rv) && protocol != baseProtocol) { + out = buf; + return NS_OK; + } + + // relative urls should never contain a host, so we always want to use + // the noauth url parser. + // use it to extract a possible scheme + rv = mParser->ParseURL(relpath, relpathLen, &scheme.mPos, &scheme.mLen, + nullptr, nullptr, nullptr, nullptr); + + // if the parser fails (for example because there is no valid scheme) + // reset the scheme and assume a relative url + if (NS_FAILED(rv)) { + scheme.Reset(); + } + + protocol.Assign(Segment(scheme)); + + // We need to do backslash replacement for the following cases: + // 1. The input is an absolute path with a http/https/ftp scheme + // 2. The input is a relative path, and the base URL has a http/https/ftp + // scheme + if ((protocol.IsEmpty() && IsSpecialProtocol(baseProtocol)) || + IsSpecialProtocol(protocol)) { + auto* start = buf.BeginWriting(); + auto* end = buf.EndWriting(); + while (start != end) { + if (*start == '?' || *start == '#') { + break; + } + if (*start == '\\') { + *start = '/'; + } + start++; + } + } + + if (scheme.mLen >= 0) { + // add some flags to coalesceFlag if it is an ftp-url + // need this later on when coalescing the resulting URL + if (SegmentIs(relpath, scheme, "ftp", true)) { + coalesceFlag = + (netCoalesceFlags)(coalesceFlag | NET_COALESCE_ALLOW_RELATIVE_ROOT | + NET_COALESCE_DOUBLE_SLASH_IS_ROOT); + } + // this URL appears to be absolute + // but try to find out more + if (SegmentIs(mScheme, relpath, scheme, true)) { + // mScheme and Scheme are the same + // but this can still be relative + if (strncmp(relpath + scheme.mPos + scheme.mLen, "://", 3) == 0) { + // now this is really absolute + // because a :// follows the scheme + result = NS_xstrdup(relpath); + } else { + // This is a deprecated form of relative urls like + // http:file or http:/path/file + // we will support it for now ... + relative = true; + offset = scheme.mLen + 1; + } + } else { + // the schemes are not the same, we are also done + // because we have to assume this is absolute + result = NS_xstrdup(relpath); + } + } else { + // add some flags to coalesceFlag if it is an ftp-url + // need this later on when coalescing the resulting URL + if (SegmentIs(mScheme, "ftp")) { + coalesceFlag = + (netCoalesceFlags)(coalesceFlag | NET_COALESCE_ALLOW_RELATIVE_ROOT | + NET_COALESCE_DOUBLE_SLASH_IS_ROOT); + } + if (relpath[0] == '/' && relpath[1] == '/') { + // this URL //host/path is almost absolute + result = AppendToSubstring(mScheme.mPos, mScheme.mLen + 1, relpath); + } else { + // then it must be relative + relative = true; + } + } + if (relative) { + uint32_t len = 0; + const char* realrelpath = relpath + offset; + switch (*realrelpath) { + case '/': + // overwrite everything after the authority + len = mAuthority.mPos + mAuthority.mLen; + break; + case '?': + // overwrite the existing ?query and #ref + if (mQuery.mLen >= 0) { + len = mQuery.mPos - 1; + } else if (mRef.mLen >= 0) { + len = mRef.mPos - 1; + } else { + len = mPath.mPos + mPath.mLen; + } + break; + case '#': + case '\0': + // overwrite the existing #ref + if (mRef.mLen < 0) { + len = mPath.mPos + mPath.mLen; + } else { + len = mRef.mPos - 1; + } + break; + default: + if (coalesceFlag & NET_COALESCE_DOUBLE_SLASH_IS_ROOT) { + if (Filename().Equals("%2F"_ns, nsCaseInsensitiveCStringComparator)) { + // if ftp URL ends with %2F then simply + // append relative part because %2F also + // marks the root directory with ftp-urls + len = mFilepath.mPos + mFilepath.mLen; + } else { + // overwrite everything after the directory + len = mDirectory.mPos + mDirectory.mLen; + } + } else { + // overwrite everything after the directory + len = mDirectory.mPos + mDirectory.mLen; + } + } + result = AppendToSubstring(0, len, realrelpath); + // locate result path + resultPath = result + mPath.mPos; + } + if (!result) { + return NS_ERROR_OUT_OF_MEMORY; + } + + if (resultPath) { + net_CoalesceDirs(coalesceFlag, resultPath); + } else { + // locate result path + resultPath = PL_strstr(result, "://"); + if (resultPath) { + resultPath = PL_strchr(resultPath + 3, '/'); + if (resultPath) { + net_CoalesceDirs(coalesceFlag, resultPath); + } + } + } + out.Adopt(result); + return NS_OK; +} + +// result may contain unescaped UTF-8 characters +NS_IMETHODIMP +nsStandardURL::GetCommonBaseSpec(nsIURI* uri2, nsACString& aResult) { + NS_ENSURE_ARG_POINTER(uri2); + + // if uri's are equal, then return uri as is + bool isEquals = false; + if (NS_SUCCEEDED(Equals(uri2, &isEquals)) && isEquals) { + return GetSpec(aResult); + } + + aResult.Truncate(); + + // check pre-path; if they don't match, then return empty string + RefPtr<nsStandardURL> stdurl2; + nsresult rv = uri2->QueryInterface(kThisImplCID, getter_AddRefs(stdurl2)); + isEquals = NS_SUCCEEDED(rv) && + SegmentIs(mScheme, stdurl2->mSpec.get(), stdurl2->mScheme) && + SegmentIs(mHost, stdurl2->mSpec.get(), stdurl2->mHost) && + SegmentIs(mUsername, stdurl2->mSpec.get(), stdurl2->mUsername) && + SegmentIs(mPassword, stdurl2->mSpec.get(), stdurl2->mPassword) && + (Port() == stdurl2->Port()); + if (!isEquals) { + return NS_OK; + } + + // scan for first mismatched character + const char *thisIndex, *thatIndex, *startCharPos; + startCharPos = mSpec.get() + mDirectory.mPos; + thisIndex = startCharPos; + thatIndex = stdurl2->mSpec.get() + mDirectory.mPos; + while ((*thisIndex == *thatIndex) && *thisIndex) { + thisIndex++; + thatIndex++; + } + + // backup to just after previous slash so we grab an appropriate path + // segment such as a directory (not partial segments) + // todo: also check for file matches which include '?' and '#' + while ((thisIndex != startCharPos) && (*(thisIndex - 1) != '/')) { + thisIndex--; + } + + // grab spec from beginning to thisIndex + aResult = Substring(mSpec, mScheme.mPos, thisIndex - mSpec.get()); + + return rv; +} + +NS_IMETHODIMP +nsStandardURL::GetRelativeSpec(nsIURI* uri2, nsACString& aResult) { + NS_ENSURE_ARG_POINTER(uri2); + + aResult.Truncate(); + + // if uri's are equal, then return empty string + bool isEquals = false; + if (NS_SUCCEEDED(Equals(uri2, &isEquals)) && isEquals) { + return NS_OK; + } + + RefPtr<nsStandardURL> stdurl2; + nsresult rv = uri2->QueryInterface(kThisImplCID, getter_AddRefs(stdurl2)); + isEquals = NS_SUCCEEDED(rv) && + SegmentIs(mScheme, stdurl2->mSpec.get(), stdurl2->mScheme) && + SegmentIs(mHost, stdurl2->mSpec.get(), stdurl2->mHost) && + SegmentIs(mUsername, stdurl2->mSpec.get(), stdurl2->mUsername) && + SegmentIs(mPassword, stdurl2->mSpec.get(), stdurl2->mPassword) && + (Port() == stdurl2->Port()); + if (!isEquals) { + return uri2->GetSpec(aResult); + } + + // scan for first mismatched character + const char *thisIndex, *thatIndex, *startCharPos; + startCharPos = mSpec.get() + mDirectory.mPos; + thisIndex = startCharPos; + thatIndex = stdurl2->mSpec.get() + mDirectory.mPos; + +#ifdef XP_WIN + bool isFileScheme = SegmentIs(mScheme, "file"); + if (isFileScheme) { + // on windows, we need to match the first segment of the path + // if these don't match then we need to return an absolute path + // skip over any leading '/' in path + while ((*thisIndex == *thatIndex) && (*thisIndex == '/')) { + thisIndex++; + thatIndex++; + } + // look for end of first segment + while ((*thisIndex == *thatIndex) && *thisIndex && (*thisIndex != '/')) { + thisIndex++; + thatIndex++; + } + + // if we didn't match through the first segment, return absolute path + if ((*thisIndex != '/') || (*thatIndex != '/')) { + return uri2->GetSpec(aResult); + } + } +#endif + + while ((*thisIndex == *thatIndex) && *thisIndex) { + thisIndex++; + thatIndex++; + } + + // backup to just after previous slash so we grab an appropriate path + // segment such as a directory (not partial segments) + // todo: also check for file matches with '#' and '?' + while ((*(thatIndex - 1) != '/') && (thatIndex != startCharPos)) { + thatIndex--; + } + + const char* limit = mSpec.get() + mFilepath.mPos + mFilepath.mLen; + + // need to account for slashes and add corresponding "../" + for (; thisIndex <= limit && *thisIndex; ++thisIndex) { + if (*thisIndex == '/') { + aResult.AppendLiteral("../"); + } + } + + // grab spec from thisIndex to end + uint32_t startPos = stdurl2->mScheme.mPos + thatIndex - stdurl2->mSpec.get(); + aResult.Append( + Substring(stdurl2->mSpec, startPos, stdurl2->mSpec.Length() - startPos)); + + return rv; +} + +//---------------------------------------------------------------------------- +// nsStandardURL::nsIURL +//---------------------------------------------------------------------------- + +// result may contain unescaped UTF-8 characters +NS_IMETHODIMP +nsStandardURL::GetFilePath(nsACString& result) { + result = Filepath(); + return NS_OK; +} + +// result may contain unescaped UTF-8 characters +NS_IMETHODIMP +nsStandardURL::GetQuery(nsACString& result) { + result = Query(); + return NS_OK; +} + +// result may contain unescaped UTF-8 characters +NS_IMETHODIMP +nsStandardURL::GetRef(nsACString& result) { + result = Ref(); + return NS_OK; +} + +NS_IMETHODIMP +nsStandardURL::GetHasRef(bool* result) { + *result = (mRef.mLen >= 0); + return NS_OK; +} + +// result may contain unescaped UTF-8 characters +NS_IMETHODIMP +nsStandardURL::GetDirectory(nsACString& result) { + result = Directory(); + return NS_OK; +} + +// result may contain unescaped UTF-8 characters +NS_IMETHODIMP +nsStandardURL::GetFileName(nsACString& result) { + result = Filename(); + return NS_OK; +} + +// result may contain unescaped UTF-8 characters +NS_IMETHODIMP +nsStandardURL::GetFileBaseName(nsACString& result) { + result = Basename(); + return NS_OK; +} + +// result may contain unescaped UTF-8 characters +NS_IMETHODIMP +nsStandardURL::GetFileExtension(nsACString& result) { + result = Extension(); + return NS_OK; +} + +nsresult nsStandardURL::SetFilePath(const nsACString& input) { + const nsPromiseFlatCString& flat = PromiseFlatCString(input); + const char* filepath = flat.get(); + + LOG(("nsStandardURL::SetFilePath [filepath=%s]\n", filepath)); + + // if there isn't a filepath, then there can't be anything + // after the path either. this url is likely uninitialized. + if (mFilepath.mLen < 0) { + return SetPathQueryRef(flat); + } + + if (filepath && *filepath) { + nsAutoCString spec; + uint32_t dirPos, basePos, extPos; + int32_t dirLen, baseLen, extLen; + nsresult rv; + + rv = mParser->ParseFilePath(filepath, flat.Length(), &dirPos, &dirLen, + &basePos, &baseLen, &extPos, &extLen); + if (NS_FAILED(rv)) { + return rv; + } + + // build up new candidate spec + spec.Assign(mSpec.get(), mPath.mPos); + + // ensure leading '/' + if (filepath[dirPos] != '/') { + spec.Append('/'); + } + + nsSegmentEncoder encoder; + + // append encoded filepath components + if (dirLen > 0) { + encoder.EncodeSegment( + Substring(filepath + dirPos, filepath + dirPos + dirLen), + esc_Directory | esc_AlwaysCopy, spec); + } + if (baseLen > 0) { + encoder.EncodeSegment( + Substring(filepath + basePos, filepath + basePos + baseLen), + esc_FileBaseName | esc_AlwaysCopy, spec); + } + if (extLen >= 0) { + spec.Append('.'); + if (extLen > 0) { + encoder.EncodeSegment( + Substring(filepath + extPos, filepath + extPos + extLen), + esc_FileExtension | esc_AlwaysCopy, spec); + } + } + + // compute the ending position of the current filepath + if (mFilepath.mLen >= 0) { + uint32_t end = mFilepath.mPos + mFilepath.mLen; + if (mSpec.Length() > end) { + spec.Append(mSpec.get() + end, mSpec.Length() - end); + } + } + + return SetSpecInternal(spec); + } + if (mPath.mLen > 1) { + mSpec.Cut(mPath.mPos + 1, mFilepath.mLen - 1); + // left shift query, and ref + ShiftFromQuery(1 - mFilepath.mLen); + // One character for '/', and if we have a query or ref we add their + // length and one extra for each '?' or '#' characters + mPath.mLen = 1 + (mQuery.mLen >= 0 ? (mQuery.mLen + 1) : 0) + + (mRef.mLen >= 0 ? (mRef.mLen + 1) : 0); + // these contain only a '/' + mDirectory.mLen = 1; + mFilepath.mLen = 1; + // these are no longer defined + mBasename.mLen = -1; + mExtension.mLen = -1; + } + return NS_OK; +} + +inline bool IsUTFEncoding(const Encoding* aEncoding) { + return aEncoding == UTF_8_ENCODING || aEncoding == UTF_16BE_ENCODING || + aEncoding == UTF_16LE_ENCODING; +} + +nsresult nsStandardURL::SetQuery(const nsACString& input) { + return SetQueryWithEncoding(input, nullptr); +} + +nsresult nsStandardURL::SetQueryWithEncoding(const nsACString& input, + const Encoding* encoding) { + const nsPromiseFlatCString& flat = PromiseFlatCString(input); + const char* query = flat.get(); + + LOG(("nsStandardURL::SetQuery [query=%s]\n", query)); + + if (IsUTFEncoding(encoding)) { + encoding = nullptr; + } + + if (mPath.mLen < 0) { + return SetPathQueryRef(flat); + } + + if (mSpec.Length() + input.Length() - Query().Length() > + StaticPrefs::network_standard_url_max_length()) { + return NS_ERROR_MALFORMED_URI; + } + + InvalidateCache(); + + if (!query || !*query) { + // remove existing query + if (mQuery.mLen >= 0) { + // remove query and leading '?' + mSpec.Cut(mQuery.mPos - 1, mQuery.mLen + 1); + ShiftFromRef(-(mQuery.mLen + 1)); + mPath.mLen -= (mQuery.mLen + 1); + mQuery.mPos = 0; + mQuery.mLen = -1; + } + return NS_OK; + } + + // filter out unexpected chars "\r\n\t" if necessary + nsAutoCString filteredURI(flat); + const ASCIIMaskArray& mask = ASCIIMask::MaskCRLFTab(); + filteredURI.StripTaggedASCII(mask); + + query = filteredURI.get(); + int32_t queryLen = filteredURI.Length(); + if (query[0] == '?') { + query++; + queryLen--; + } + + if (mQuery.mLen < 0) { + if (mRef.mLen < 0) { + mQuery.mPos = mSpec.Length(); + } else { + mQuery.mPos = mRef.mPos - 1; + } + mSpec.Insert('?', mQuery.mPos); + mQuery.mPos++; + mQuery.mLen = 0; + // the insertion pushes these out by 1 + mPath.mLen++; + mRef.mPos++; + } + + // encode query if necessary + nsAutoCString buf; + bool encoded; + nsSegmentEncoder encoder(encoding); + encoder.EncodeSegmentCount(query, URLSegment(0, queryLen), esc_Query, buf, + encoded); + if (encoded) { + query = buf.get(); + queryLen = buf.Length(); + } + + int32_t shift = ReplaceSegment(mQuery.mPos, mQuery.mLen, query, queryLen); + + if (shift) { + mQuery.mLen = queryLen; + mPath.mLen += shift; + ShiftFromRef(shift); + } + return NS_OK; +} + +nsresult nsStandardURL::SetRef(const nsACString& input) { + const nsPromiseFlatCString& flat = PromiseFlatCString(input); + const char* ref = flat.get(); + + LOG(("nsStandardURL::SetRef [ref=%s]\n", ref)); + + if (mPath.mLen < 0) { + return SetPathQueryRef(flat); + } + + if (mSpec.Length() + input.Length() - Ref().Length() > + StaticPrefs::network_standard_url_max_length()) { + return NS_ERROR_MALFORMED_URI; + } + + InvalidateCache(); + + if (!ref || !*ref) { + // remove existing ref + if (mRef.mLen >= 0) { + // remove ref and leading '#' + mSpec.Cut(mRef.mPos - 1, mRef.mLen + 1); + mPath.mLen -= (mRef.mLen + 1); + mRef.mPos = 0; + mRef.mLen = -1; + } + return NS_OK; + } + + // filter out unexpected chars "\r\n\t" if necessary + nsAutoCString filteredURI(flat); + const ASCIIMaskArray& mask = ASCIIMask::MaskCRLFTab(); + filteredURI.StripTaggedASCII(mask); + + ref = filteredURI.get(); + int32_t refLen = filteredURI.Length(); + if (ref[0] == '#') { + ref++; + refLen--; + } + + if (mRef.mLen < 0) { + mSpec.Append('#'); + ++mPath.mLen; // Include the # in the path. + mRef.mPos = mSpec.Length(); + mRef.mLen = 0; + } + + // If precent encoding is necessary, `ref` will point to `buf`'s content. + // `buf` needs to outlive any use of the `ref` pointer. + nsAutoCString buf; + // encode ref if necessary + bool encoded; + nsSegmentEncoder encoder; + encoder.EncodeSegmentCount(ref, URLSegment(0, refLen), esc_Ref, buf, encoded); + if (encoded) { + ref = buf.get(); + refLen = buf.Length(); + } + + int32_t shift = ReplaceSegment(mRef.mPos, mRef.mLen, ref, refLen); + mPath.mLen += shift; + mRef.mLen = refLen; + return NS_OK; +} + +nsresult nsStandardURL::SetFileNameInternal(const nsACString& input) { + const nsPromiseFlatCString& flat = PromiseFlatCString(input); + const char* filename = flat.get(); + + LOG(("nsStandardURL::SetFileNameInternal [filename=%s]\n", filename)); + + if (mPath.mLen < 0) { + return SetPathQueryRef(flat); + } + + if (mSpec.Length() + input.Length() - Filename().Length() > + StaticPrefs::network_standard_url_max_length()) { + return NS_ERROR_MALFORMED_URI; + } + + int32_t shift = 0; + + if (!(filename && *filename)) { + // remove the filename + if (mBasename.mLen > 0) { + if (mExtension.mLen >= 0) { + mBasename.mLen += (mExtension.mLen + 1); + } + mSpec.Cut(mBasename.mPos, mBasename.mLen); + shift = -mBasename.mLen; + mBasename.mLen = 0; + mExtension.mLen = -1; + } + } else { + nsresult rv; + URLSegment basename, extension; + + // let the parser locate the basename and extension + rv = mParser->ParseFileName(filename, flat.Length(), &basename.mPos, + &basename.mLen, &extension.mPos, + &extension.mLen); + if (NS_FAILED(rv)) { + return rv; + } + + if (basename.mLen < 0) { + // remove existing filename + if (mBasename.mLen >= 0) { + uint32_t len = mBasename.mLen; + if (mExtension.mLen >= 0) { + len += (mExtension.mLen + 1); + } + mSpec.Cut(mBasename.mPos, len); + shift = -int32_t(len); + mBasename.mLen = 0; + mExtension.mLen = -1; + } + } else { + nsAutoCString newFilename; + bool ignoredOut; + nsSegmentEncoder encoder; + basename.mLen = encoder.EncodeSegmentCount( + filename, basename, esc_FileBaseName | esc_AlwaysCopy, newFilename, + ignoredOut); + if (extension.mLen >= 0) { + newFilename.Append('.'); + extension.mLen = encoder.EncodeSegmentCount( + filename, extension, esc_FileExtension | esc_AlwaysCopy, + newFilename, ignoredOut); + } + + if (mBasename.mLen < 0) { + // insert new filename + mBasename.mPos = mDirectory.mPos + mDirectory.mLen; + mSpec.Insert(newFilename, mBasename.mPos); + shift = newFilename.Length(); + } else { + // replace existing filename + uint32_t oldLen = uint32_t(mBasename.mLen); + if (mExtension.mLen >= 0) { + oldLen += (mExtension.mLen + 1); + } + mSpec.Replace(mBasename.mPos, oldLen, newFilename); + shift = newFilename.Length() - oldLen; + } + + mBasename.mLen = basename.mLen; + mExtension.mLen = extension.mLen; + if (mExtension.mLen >= 0) { + mExtension.mPos = mBasename.mPos + mBasename.mLen + 1; + } + } + } + if (shift) { + ShiftFromQuery(shift); + mFilepath.mLen += shift; + mPath.mLen += shift; + } + return NS_OK; +} + +nsresult nsStandardURL::SetFileBaseNameInternal(const nsACString& input) { + nsAutoCString extension; + nsresult rv = GetFileExtension(extension); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoCString newFileName(input); + + if (!extension.IsEmpty()) { + newFileName.Append('.'); + newFileName.Append(extension); + } + + return SetFileNameInternal(newFileName); +} + +nsresult nsStandardURL::SetFileExtensionInternal(const nsACString& input) { + nsAutoCString newFileName; + nsresult rv = GetFileBaseName(newFileName); + NS_ENSURE_SUCCESS(rv, rv); + + if (!input.IsEmpty()) { + newFileName.Append('.'); + newFileName.Append(input); + } + + return SetFileNameInternal(newFileName); +} + +//---------------------------------------------------------------------------- +// nsStandardURL::nsIFileURL +//---------------------------------------------------------------------------- + +nsresult nsStandardURL::EnsureFile() { + MOZ_ASSERT(mSupportsFileURL, + "EnsureFile() called on a URL that doesn't support files!"); + + if (mFile) { + // Nothing to do + return NS_OK; + } + + // Parse the spec if we don't have a cached result + if (mSpec.IsEmpty()) { + NS_WARNING("url not initialized"); + return NS_ERROR_NOT_INITIALIZED; + } + + if (!SegmentIs(mScheme, "file")) { + NS_WARNING("not a file URL"); + return NS_ERROR_FAILURE; + } + + return net_GetFileFromURLSpec(mSpec, getter_AddRefs(mFile)); +} + +NS_IMETHODIMP +nsStandardURL::GetFile(nsIFile** result) { + MOZ_ASSERT(mSupportsFileURL, + "GetFile() called on a URL that doesn't support files!"); + + nsresult rv = EnsureFile(); + if (NS_FAILED(rv)) { + return rv; + } + + if (LOG_ENABLED()) { + LOG(("nsStandardURL::GetFile [this=%p spec=%s resulting_path=%s]\n", this, + mSpec.get(), mFile->HumanReadablePath().get())); + } + + // clone the file, so the caller can modify it. + // XXX nsIFileURL.idl specifies that the consumer must _not_ modify the + // nsIFile returned from this method; but it seems that some folks do + // (see bug 161921). until we can be sure that all the consumers are + // behaving themselves, we'll stay on the safe side and clone the file. + // see bug 212724 about fixing the consumers. + return mFile->Clone(result); +} + +nsresult nsStandardURL::SetFile(nsIFile* file) { + NS_ENSURE_ARG_POINTER(file); + + nsresult rv; + nsAutoCString url; + + rv = net_GetURLSpecFromFile(file, url); + if (NS_FAILED(rv)) { + return rv; + } + + uint32_t oldURLType = mURLType; + uint32_t oldDefaultPort = mDefaultPort; + rv = Init(nsIStandardURL::URLTYPE_NO_AUTHORITY, -1, url, nullptr, nullptr); + + if (NS_FAILED(rv)) { + // Restore the old url type and default port if the call to Init fails. + mURLType = oldURLType; + mDefaultPort = oldDefaultPort; + return rv; + } + + // must clone |file| since its value is not guaranteed to remain constant + InvalidateCache(); + if (NS_FAILED(file->Clone(getter_AddRefs(mFile)))) { + NS_WARNING("nsIFile::Clone failed"); + // failure to clone is not fatal (GetFile will generate mFile) + mFile = nullptr; + } + + return NS_OK; +} + +//---------------------------------------------------------------------------- +// nsStandardURL::nsIStandardURL +//---------------------------------------------------------------------------- + +nsresult nsStandardURL::Init(uint32_t urlType, int32_t defaultPort, + const nsACString& spec, const char* charset, + nsIURI* baseURI) { + if (spec.Length() > StaticPrefs::network_standard_url_max_length() || + defaultPort > std::numeric_limits<uint16_t>::max()) { + return NS_ERROR_MALFORMED_URI; + } + + InvalidateCache(); + + switch (urlType) { + case URLTYPE_STANDARD: + mParser = net_GetStdURLParser(); + break; + case URLTYPE_AUTHORITY: + mParser = net_GetAuthURLParser(); + break; + case URLTYPE_NO_AUTHORITY: + mParser = net_GetNoAuthURLParser(); + break; + default: + MOZ_ASSERT_UNREACHABLE("bad urlType"); + return NS_ERROR_INVALID_ARG; + } + mDefaultPort = defaultPort; + mURLType = urlType; + + const auto* encoding = + charset ? Encoding::ForLabelNoReplacement(MakeStringSpan(charset)) + : nullptr; + // URI can't be encoded in UTF-16BE or UTF-16LE. Truncate encoding + // if it is one of utf encodings (since a null encoding implies + // UTF-8, this is safe even if encoding is UTF-8). + if (IsUTFEncoding(encoding)) { + encoding = nullptr; + } + + if (baseURI && net_IsAbsoluteURL(spec)) { + baseURI = nullptr; + } + + if (!baseURI) { + return SetSpecWithEncoding(spec, encoding); + } + + nsAutoCString buf; + nsresult rv = baseURI->Resolve(spec, buf); + if (NS_FAILED(rv)) { + return rv; + } + + return SetSpecWithEncoding(buf, encoding); +} + +nsresult nsStandardURL::SetDefaultPort(int32_t aNewDefaultPort) { + InvalidateCache(); + + // should never be more than 16 bit + if (aNewDefaultPort >= std::numeric_limits<uint16_t>::max()) { + return NS_ERROR_MALFORMED_URI; + } + + // If we're already using the new default-port as a custom port, then clear + // it off of our mSpec & set mPort to -1, to indicate that we'll be using + // the default from now on (which happens to match what we already had). + if (mPort == aNewDefaultPort) { + ReplacePortInSpec(-1); + mPort = -1; + } + mDefaultPort = aNewDefaultPort; + + return NS_OK; +} + +//---------------------------------------------------------------------------- +// nsStandardURL::nsISerializable +//---------------------------------------------------------------------------- + +NS_IMETHODIMP +nsStandardURL::Read(nsIObjectInputStream* stream) { + MOZ_ASSERT_UNREACHABLE("Use nsIURIMutator.read() instead"); + return NS_ERROR_NOT_IMPLEMENTED; +} + +nsresult nsStandardURL::ReadPrivate(nsIObjectInputStream* stream) { + MOZ_ASSERT(mDisplayHost.IsEmpty(), "Shouldn't have cached unicode host"); + + nsresult rv; + + uint32_t urlType; + rv = stream->Read32(&urlType); + if (NS_FAILED(rv)) { + return rv; + } + mURLType = urlType; + switch (mURLType) { + case URLTYPE_STANDARD: + mParser = net_GetStdURLParser(); + break; + case URLTYPE_AUTHORITY: + mParser = net_GetAuthURLParser(); + break; + case URLTYPE_NO_AUTHORITY: + mParser = net_GetNoAuthURLParser(); + break; + default: + MOZ_ASSERT_UNREACHABLE("bad urlType"); + return NS_ERROR_FAILURE; + } + + rv = stream->Read32((uint32_t*)&mPort); + if (NS_FAILED(rv)) { + return rv; + } + + rv = stream->Read32((uint32_t*)&mDefaultPort); + if (NS_FAILED(rv)) { + return rv; + } + + rv = NS_ReadOptionalCString(stream, mSpec); + if (NS_FAILED(rv)) { + return rv; + } + + rv = ReadSegment(stream, mScheme); + if (NS_FAILED(rv)) { + return rv; + } + + rv = ReadSegment(stream, mAuthority); + if (NS_FAILED(rv)) { + return rv; + } + + rv = ReadSegment(stream, mUsername); + if (NS_FAILED(rv)) { + return rv; + } + + rv = ReadSegment(stream, mPassword); + if (NS_FAILED(rv)) { + return rv; + } + + rv = ReadSegment(stream, mHost); + if (NS_FAILED(rv)) { + return rv; + } + + rv = ReadSegment(stream, mPath); + if (NS_FAILED(rv)) { + return rv; + } + + rv = ReadSegment(stream, mFilepath); + if (NS_FAILED(rv)) { + return rv; + } + + rv = ReadSegment(stream, mDirectory); + if (NS_FAILED(rv)) { + return rv; + } + + rv = ReadSegment(stream, mBasename); + if (NS_FAILED(rv)) { + return rv; + } + + rv = ReadSegment(stream, mExtension); + if (NS_FAILED(rv)) { + return rv; + } + + // handle forward compatibility from older serializations that included mParam + URLSegment old_param; + rv = ReadSegment(stream, old_param); + if (NS_FAILED(rv)) { + return rv; + } + + rv = ReadSegment(stream, mQuery); + if (NS_FAILED(rv)) { + return rv; + } + + rv = ReadSegment(stream, mRef); + if (NS_FAILED(rv)) { + return rv; + } + + nsAutoCString oldOriginCharset; + rv = NS_ReadOptionalCString(stream, oldOriginCharset); + if (NS_FAILED(rv)) { + return rv; + } + + bool isMutable; + rv = stream->ReadBoolean(&isMutable); + if (NS_FAILED(rv)) { + return rv; + } + Unused << isMutable; + + bool supportsFileURL; + rv = stream->ReadBoolean(&supportsFileURL); + if (NS_FAILED(rv)) { + return rv; + } + mSupportsFileURL = supportsFileURL; + + // wait until object is set up, then modify path to include the param + if (old_param.mLen >= 0) { // note that mLen=0 is ";" + // If this wasn't empty, it marks characters between the end of the + // file and start of the query - mPath should include the param, + // query and ref already. Bump the mFilePath and + // directory/basename/extension components to include this. + mFilepath.Merge(mSpec, ';', old_param); + mDirectory.Merge(mSpec, ';', old_param); + mBasename.Merge(mSpec, ';', old_param); + mExtension.Merge(mSpec, ';', old_param); + } + + rv = CheckIfHostIsAscii(); + if (NS_FAILED(rv)) { + return rv; + } + + return NS_OK; +} + +NS_IMETHODIMP +nsStandardURL::Write(nsIObjectOutputStream* stream) { + MOZ_ASSERT(mSpec.Length() <= StaticPrefs::network_standard_url_max_length(), + "The spec should never be this long, we missed a check."); + nsresult rv; + + rv = stream->Write32(mURLType); + if (NS_FAILED(rv)) { + return rv; + } + + rv = stream->Write32(uint32_t(mPort)); + if (NS_FAILED(rv)) { + return rv; + } + + rv = stream->Write32(uint32_t(mDefaultPort)); + if (NS_FAILED(rv)) { + return rv; + } + + rv = NS_WriteOptionalStringZ(stream, mSpec.get()); + if (NS_FAILED(rv)) { + return rv; + } + + rv = WriteSegment(stream, mScheme); + if (NS_FAILED(rv)) { + return rv; + } + + rv = WriteSegment(stream, mAuthority); + if (NS_FAILED(rv)) { + return rv; + } + + rv = WriteSegment(stream, mUsername); + if (NS_FAILED(rv)) { + return rv; + } + + rv = WriteSegment(stream, mPassword); + if (NS_FAILED(rv)) { + return rv; + } + + rv = WriteSegment(stream, mHost); + if (NS_FAILED(rv)) { + return rv; + } + + rv = WriteSegment(stream, mPath); + if (NS_FAILED(rv)) { + return rv; + } + + rv = WriteSegment(stream, mFilepath); + if (NS_FAILED(rv)) { + return rv; + } + + rv = WriteSegment(stream, mDirectory); + if (NS_FAILED(rv)) { + return rv; + } + + rv = WriteSegment(stream, mBasename); + if (NS_FAILED(rv)) { + return rv; + } + + rv = WriteSegment(stream, mExtension); + if (NS_FAILED(rv)) { + return rv; + } + + // for backwards compatibility since we removed mParam. Note that this will + // mean that an older browser will read "" for mParam, and the param(s) will + // be part of mPath (as they after the removal of special handling). It only + // matters if you downgrade a browser to before the patch. + URLSegment empty; + rv = WriteSegment(stream, empty); + if (NS_FAILED(rv)) { + return rv; + } + + rv = WriteSegment(stream, mQuery); + if (NS_FAILED(rv)) { + return rv; + } + + rv = WriteSegment(stream, mRef); + if (NS_FAILED(rv)) { + return rv; + } + + // former origin charset + rv = NS_WriteOptionalStringZ(stream, ""); + if (NS_FAILED(rv)) { + return rv; + } + + // former mMutable + rv = stream->WriteBoolean(false); + if (NS_FAILED(rv)) { + return rv; + } + + rv = stream->WriteBoolean(mSupportsFileURL); + if (NS_FAILED(rv)) { + return rv; + } + + // mDisplayHost is just a cache that can be recovered as needed. + + return NS_OK; +} + +inline ipc::StandardURLSegment ToIPCSegment( + const nsStandardURL::URLSegment& aSegment) { + return ipc::StandardURLSegment(aSegment.mPos, aSegment.mLen); +} + +[[nodiscard]] inline bool FromIPCSegment( + const nsACString& aSpec, const ipc::StandardURLSegment& aSegment, + nsStandardURL::URLSegment& aTarget) { + // This seems to be just an empty segment. + if (aSegment.length() == -1) { + aTarget = nsStandardURL::URLSegment(); + return true; + } + + // A value of -1 means an empty segment, but < -1 is undefined. + if (NS_WARN_IF(aSegment.length() < -1)) { + return false; + } + + CheckedInt<uint32_t> segmentLen = aSegment.position(); + segmentLen += aSegment.length(); + // Make sure the segment does not extend beyond the spec. + if (NS_WARN_IF(!segmentLen.isValid() || + segmentLen.value() > aSpec.Length())) { + return false; + } + + aTarget.mPos = aSegment.position(); + aTarget.mLen = aSegment.length(); + + return true; +} + +void nsStandardURL::Serialize(URIParams& aParams) { + MOZ_ASSERT(mSpec.Length() <= StaticPrefs::network_standard_url_max_length(), + "The spec should never be this long, we missed a check."); + StandardURLParams params; + + params.urlType() = mURLType; + params.port() = mPort; + params.defaultPort() = mDefaultPort; + params.spec() = mSpec; + params.scheme() = ToIPCSegment(mScheme); + params.authority() = ToIPCSegment(mAuthority); + params.username() = ToIPCSegment(mUsername); + params.password() = ToIPCSegment(mPassword); + params.host() = ToIPCSegment(mHost); + params.path() = ToIPCSegment(mPath); + params.filePath() = ToIPCSegment(mFilepath); + params.directory() = ToIPCSegment(mDirectory); + params.baseName() = ToIPCSegment(mBasename); + params.extension() = ToIPCSegment(mExtension); + params.query() = ToIPCSegment(mQuery); + params.ref() = ToIPCSegment(mRef); + params.supportsFileURL() = !!mSupportsFileURL; + params.isSubstituting() = false; + // mDisplayHost is just a cache that can be recovered as needed. + + aParams = params; +} + +bool nsStandardURL::Deserialize(const URIParams& aParams) { + MOZ_ASSERT(mDisplayHost.IsEmpty(), "Shouldn't have cached unicode host"); + MOZ_ASSERT(!mFile, "Shouldn't have cached file"); + + if (aParams.type() != URIParams::TStandardURLParams) { + NS_ERROR("Received unknown parameters from the other process!"); + return false; + } + + const StandardURLParams& params = aParams.get_StandardURLParams(); + + mURLType = params.urlType(); + switch (mURLType) { + case URLTYPE_STANDARD: + mParser = net_GetStdURLParser(); + break; + case URLTYPE_AUTHORITY: + mParser = net_GetAuthURLParser(); + break; + case URLTYPE_NO_AUTHORITY: + mParser = net_GetNoAuthURLParser(); + break; + default: + MOZ_ASSERT_UNREACHABLE("bad urlType"); + return false; + } + + mPort = params.port(); + mDefaultPort = params.defaultPort(); + mSpec = params.spec(); + NS_ENSURE_TRUE( + mSpec.Length() <= StaticPrefs::network_standard_url_max_length(), false); + NS_ENSURE_TRUE(FromIPCSegment(mSpec, params.scheme(), mScheme), false); + NS_ENSURE_TRUE(FromIPCSegment(mSpec, params.authority(), mAuthority), false); + NS_ENSURE_TRUE(FromIPCSegment(mSpec, params.username(), mUsername), false); + NS_ENSURE_TRUE(FromIPCSegment(mSpec, params.password(), mPassword), false); + NS_ENSURE_TRUE(FromIPCSegment(mSpec, params.host(), mHost), false); + NS_ENSURE_TRUE(FromIPCSegment(mSpec, params.path(), mPath), false); + NS_ENSURE_TRUE(FromIPCSegment(mSpec, params.filePath(), mFilepath), false); + NS_ENSURE_TRUE(FromIPCSegment(mSpec, params.directory(), mDirectory), false); + NS_ENSURE_TRUE(FromIPCSegment(mSpec, params.baseName(), mBasename), false); + NS_ENSURE_TRUE(FromIPCSegment(mSpec, params.extension(), mExtension), false); + NS_ENSURE_TRUE(FromIPCSegment(mSpec, params.query(), mQuery), false); + NS_ENSURE_TRUE(FromIPCSegment(mSpec, params.ref(), mRef), false); + + mSupportsFileURL = params.supportsFileURL(); + + nsresult rv = CheckIfHostIsAscii(); + if (NS_FAILED(rv)) { + return false; + } + + // Some sanity checks + NS_ENSURE_TRUE(mScheme.mPos == 0, false); + NS_ENSURE_TRUE(mScheme.mLen > 0, false); + // Make sure scheme is followed by :// (3 characters) + NS_ENSURE_TRUE(mScheme.mLen < INT32_MAX - 3, false); // avoid overflow + NS_ENSURE_TRUE(mSpec.Length() >= (uint32_t)mScheme.mLen + 3, false); + NS_ENSURE_TRUE( + nsDependentCSubstring(mSpec, mScheme.mLen, 3).EqualsLiteral("://"), + false); + NS_ENSURE_TRUE(mPath.mLen != -1 && mSpec.CharAt(mPath.mPos) == '/', false); + NS_ENSURE_TRUE(mPath.mPos == mFilepath.mPos, false); + NS_ENSURE_TRUE(mQuery.mLen == -1 || + (mQuery.mPos > 0 && mSpec.CharAt(mQuery.mPos - 1) == '?'), + false); + NS_ENSURE_TRUE( + mRef.mLen == -1 || (mRef.mPos > 0 && mSpec.CharAt(mRef.mPos - 1) == '#'), + false); + + return true; +} + +//---------------------------------------------------------------------------- +// nsStandardURL::nsISizeOf +//---------------------------------------------------------------------------- + +size_t nsStandardURL::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const { + return mSpec.SizeOfExcludingThisIfUnshared(aMallocSizeOf) + + mDisplayHost.SizeOfExcludingThisIfUnshared(aMallocSizeOf); + + // Measurement of the following members may be added later if DMD finds it is + // worthwhile: + // - mParser + // - mFile +} + +size_t nsStandardURL::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const { + return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf); +} + +} // namespace net +} // namespace mozilla + +// For unit tests. Including nsStandardURL.h seems to cause problems +nsresult Test_NormalizeIPv4(const nsACString& host, nsCString& result) { + return mozilla::net::nsStandardURL::NormalizeIPv4(host, result); +} diff --git a/netwerk/base/nsStandardURL.h b/netwerk/base/nsStandardURL.h new file mode 100644 index 0000000000..6efb58648d --- /dev/null +++ b/netwerk/base/nsStandardURL.h @@ -0,0 +1,550 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef nsStandardURL_h__ +#define nsStandardURL_h__ + +#include "nsString.h" +#include "nsISerializable.h" +#include "nsIFileURL.h" +#include "nsIStandardURL.h" +#include "mozilla/Encoding.h" +#include "nsCOMPtr.h" +#include "nsURLHelper.h" +#include "nsISizeOf.h" +#include "mozilla/Attributes.h" +#include "mozilla/LinkedList.h" +#include "mozilla/MemoryReporting.h" +#include "nsISensitiveInfoHiddenURI.h" +#include "nsIURIMutator.h" + +#ifdef NS_BUILD_REFCNT_LOGGING +# define DEBUG_DUMP_URLS_AT_SHUTDOWN +#endif + +class nsIBinaryInputStream; +class nsIBinaryOutputStream; +class nsIIDNService; +class nsIPrefBranch; +class nsIFile; +class nsIURLParser; + +namespace mozilla { +class Encoding; +namespace net { + +//----------------------------------------------------------------------------- +// standard URL implementation +//----------------------------------------------------------------------------- + +class nsStandardURL : public nsIFileURL, + public nsIStandardURL, + public nsISerializable, + public nsISizeOf, + public nsISensitiveInfoHiddenURI +#ifdef DEBUG_DUMP_URLS_AT_SHUTDOWN + , + public LinkedListElement<nsStandardURL> +#endif +{ + protected: + virtual ~nsStandardURL(); + explicit nsStandardURL(bool aSupportsFileURL = false, bool aTrackURL = true); + + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIURI + NS_DECL_NSIURL + NS_DECL_NSIFILEURL + NS_DECL_NSISTANDARDURL + NS_DECL_NSISERIALIZABLE + NS_DECL_NSISENSITIVEINFOHIDDENURI + + // nsISizeOf + virtual size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const override; + virtual size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const override; + + static void InitGlobalObjects(); + static void ShutdownGlobalObjects(); + + public: /* internal -- HPUX compiler can't handle this being private */ + // + // location and length of an url segment relative to mSpec + // + struct URLSegment { + uint32_t mPos; + int32_t mLen; + + URLSegment() : mPos(0), mLen(-1) {} + URLSegment(uint32_t pos, int32_t len) : mPos(pos), mLen(len) {} + URLSegment(const URLSegment& aCopy) = default; + void Reset() { + mPos = 0; + mLen = -1; + } + // Merge another segment following this one to it if they're contiguous + // Assumes we have something like "foo;bar" where this object is 'foo' and + // right is 'bar'. + void Merge(const nsCString& spec, const char separator, + const URLSegment& right) { + if (mLen >= 0 && *(spec.get() + mPos + mLen) == separator && + mPos + mLen + 1 == right.mPos) { + mLen += 1 + right.mLen; + } + } + }; + + // + // URL segment encoder : performs charset conversion and URL escaping. + // + class nsSegmentEncoder { + public: + explicit nsSegmentEncoder(const Encoding* encoding = nullptr); + + // Encode the given segment if necessary, and return the length of + // the encoded segment. The encoded segment is appended to |aOut| + // if and only if encoding is required. + int32_t EncodeSegmentCount(const char* str, const URLSegment& aSeg, + int16_t mask, nsCString& aOut, bool& appended, + uint32_t extraLen = 0); + + // Encode the given string if necessary, and return a reference to + // the encoded string. Returns a reference to |result| if encoding + // is required. Otherwise, a reference to |str| is returned. + const nsACString& EncodeSegment(const nsACString& str, int16_t mask, + nsCString& result); + + private: + const Encoding* mEncoding; + }; + friend class nsSegmentEncoder; + + static nsresult NormalizeIPv4(const nsACString& host, nsCString& result); + + protected: + // enum used in a few places to specify how .ref attribute should be handled + enum RefHandlingEnum { eIgnoreRef, eHonorRef, eReplaceRef }; + + // Helper to share code between Equals and EqualsExceptRef + // NOTE: *not* virtual, because no one needs to override this so far... + nsresult EqualsInternal(nsIURI* unknownOther, RefHandlingEnum refHandlingMode, + bool* result); + + virtual nsStandardURL* StartClone(); + + // Helper to share code between Clone methods. + nsresult CloneInternal(RefHandlingEnum aRefHandlingMode, + const nsACString& aNewRef, nsIURI** aClone); + // Helper method that copies member variables from the source StandardURL + // if copyCached = true, it will also copy mFile and mDisplayHost + nsresult CopyMembers(nsStandardURL* source, RefHandlingEnum mode, + const nsACString& newRef, bool copyCached = false); + + // Helper for subclass implementation of GetFile(). Subclasses that map + // URIs to files in a special way should implement this method. It should + // ensure that our mFile is initialized, if it's possible. + // returns NS_ERROR_NO_INTERFACE if the url does not map to a file + virtual nsresult EnsureFile(); + + virtual nsresult Clone(nsIURI** aURI); + virtual nsresult SetSpecInternal(const nsACString& input); + virtual nsresult SetScheme(const nsACString& input); + virtual nsresult SetUserPass(const nsACString& input); + virtual nsresult SetUsername(const nsACString& input); + virtual nsresult SetPassword(const nsACString& input); + virtual nsresult SetHostPort(const nsACString& aValue); + virtual nsresult SetHost(const nsACString& input); + virtual nsresult SetPort(int32_t port); + virtual nsresult SetPathQueryRef(const nsACString& input); + virtual nsresult SetRef(const nsACString& input); + virtual nsresult SetFilePath(const nsACString& input); + virtual nsresult SetQuery(const nsACString& input); + virtual nsresult SetQueryWithEncoding(const nsACString& input, + const Encoding* encoding); + bool Deserialize(const mozilla::ipc::URIParams&); + nsresult ReadPrivate(nsIObjectInputStream* stream); + + private: + nsresult Init(uint32_t urlType, int32_t defaultPort, const nsACString& spec, + const char* charset, nsIURI* baseURI); + nsresult SetDefaultPort(int32_t aNewDefaultPort); + nsresult SetFile(nsIFile* file); + + nsresult SetFileNameInternal(const nsACString& input); + nsresult SetFileBaseNameInternal(const nsACString& input); + nsresult SetFileExtensionInternal(const nsACString& input); + + int32_t Port() { return mPort == -1 ? mDefaultPort : mPort; } + + void ReplacePortInSpec(int32_t aNewPort); + void Clear(); + void InvalidateCache(bool invalidateCachedFile = true); + + bool ValidIPv6orHostname(const char* host, uint32_t length); + static bool IsValidOfBase(unsigned char c, const uint32_t base); + nsresult NormalizeIDN(const nsACString& host, nsCString& result); + nsresult CheckIfHostIsAscii(); + void CoalescePath(netCoalesceFlags coalesceFlag, char* path); + + uint32_t AppendSegmentToBuf(char*, uint32_t, const char*, + const URLSegment& input, URLSegment& output, + const nsCString* esc = nullptr, + bool useEsc = false, int32_t* diff = nullptr); + uint32_t AppendToBuf(char*, uint32_t, const char*, uint32_t); + + nsresult BuildNormalizedSpec(const char* spec, const Encoding* encoding); + nsresult SetSpecWithEncoding(const nsACString& input, + const Encoding* encoding); + + bool SegmentIs(const URLSegment& seg, const char* val, + bool ignoreCase = false); + bool SegmentIs(const char* spec, const URLSegment& seg, const char* val, + bool ignoreCase = false); + bool SegmentIs(const URLSegment& seg1, const char* val, + const URLSegment& seg2, bool ignoreCase = false); + + int32_t ReplaceSegment(uint32_t pos, uint32_t len, const char* val, + uint32_t valLen); + int32_t ReplaceSegment(uint32_t pos, uint32_t len, const nsACString& val); + + nsresult ParseURL(const char* spec, int32_t specLen); + nsresult ParsePath(const char* spec, uint32_t pathPos, int32_t pathLen = -1); + + char* AppendToSubstring(uint32_t pos, int32_t len, const char* tail); + + // dependent substring helpers + const nsDependentCSubstring Segment(uint32_t pos, int32_t len); // see below + const nsDependentCSubstring Segment(const URLSegment& s) { + return Segment(s.mPos, s.mLen); + } + + // dependent substring getters + const nsDependentCSubstring Prepath(); // see below + const nsDependentCSubstring Scheme() { return Segment(mScheme); } + const nsDependentCSubstring Userpass(bool includeDelim = false); // see below + const nsDependentCSubstring Username() { return Segment(mUsername); } + const nsDependentCSubstring Password() { return Segment(mPassword); } + const nsDependentCSubstring Hostport(); // see below + const nsDependentCSubstring Host(); // see below + const nsDependentCSubstring Path() { return Segment(mPath); } + const nsDependentCSubstring Filepath() { return Segment(mFilepath); } + const nsDependentCSubstring Directory() { return Segment(mDirectory); } + const nsDependentCSubstring Filename(); // see below + const nsDependentCSubstring Basename() { return Segment(mBasename); } + const nsDependentCSubstring Extension() { return Segment(mExtension); } + const nsDependentCSubstring Query() { return Segment(mQuery); } + const nsDependentCSubstring Ref() { return Segment(mRef); } + + // shift the URLSegments to the right by diff + void ShiftFromAuthority(int32_t diff); + void ShiftFromUsername(int32_t diff); + void ShiftFromPassword(int32_t diff); + void ShiftFromHost(int32_t diff); + void ShiftFromPath(int32_t diff); + void ShiftFromFilepath(int32_t diff); + void ShiftFromDirectory(int32_t diff); + void ShiftFromBasename(int32_t diff); + void ShiftFromExtension(int32_t diff); + void ShiftFromQuery(int32_t diff); + void ShiftFromRef(int32_t diff); + + // fastload helper functions + nsresult ReadSegment(nsIBinaryInputStream*, URLSegment&); + nsresult WriteSegment(nsIBinaryOutputStream*, const URLSegment&); + + void FindHostLimit(nsACString::const_iterator& aStart, + nsACString::const_iterator& aEnd); + + // Asserts that the URLSegment has sane values + static void SanityCheck(const URLSegment&, const nsCString&); + + // mSpec contains the normalized version of the URL spec (UTF-8 encoded). + nsCString mSpec; + int32_t mDefaultPort; + int32_t mPort; + + // url parts (relative to mSpec) + URLSegment mScheme; + URLSegment mAuthority; + URLSegment mUsername; + URLSegment mPassword; + URLSegment mHost; + URLSegment mPath; + URLSegment mFilepath; + URLSegment mDirectory; + URLSegment mBasename; + URLSegment mExtension; + URLSegment mQuery; + URLSegment mRef; + + nsCOMPtr<nsIURLParser> mParser; + + // mFile is protected so subclasses can access it directly + protected: + nsCOMPtr<nsIFile> mFile; // cached result for nsIFileURL::GetFile + + private: + // cached result for nsIURI::GetDisplayHost + nsCString mDisplayHost; + + enum { eEncoding_Unknown, eEncoding_ASCII, eEncoding_UTF8 }; + + uint32_t mURLType : 2; // nsIStandardURL::URLTYPE_xxx + uint32_t mSupportsFileURL : 1; // QI to nsIFileURL? + uint32_t mCheckedIfHostA : 1; // If set to true, it means either that + // mDisplayHost has a been initialized, or + // that the hostname is not punycode + + // global objects. + static StaticRefPtr<nsIIDNService> gIDN; + static const char gHostLimitDigits[]; + static bool gInitialized; + + public: +#ifdef DEBUG_DUMP_URLS_AT_SHUTDOWN + void PrintSpec() const { printf(" %s\n", mSpec.get()); } +#endif + + public: + // We make this implementation a template so that we can avoid writing + // the same code for SubstitutingURL (which extends nsStandardURL) + template <class T> + class TemplatedMutator : public nsIURIMutator, + public BaseURIMutator<T>, + public nsIStandardURLMutator, + public nsIURLMutator, + public nsIFileURLMutator, + public nsISerializable { + NS_FORWARD_SAFE_NSIURISETTERS_RET(BaseURIMutator<T>::mURI) + + [[nodiscard]] NS_IMETHOD Deserialize( + const mozilla::ipc::URIParams& aParams) override { + return BaseURIMutator<T>::InitFromIPCParams(aParams); + } + + NS_IMETHOD + Write(nsIObjectOutputStream* aOutputStream) override { + MOZ_ASSERT_UNREACHABLE("Use nsIURIMutator.read() instead"); + return NS_ERROR_NOT_IMPLEMENTED; + } + + [[nodiscard]] NS_IMETHOD Read(nsIObjectInputStream* aStream) override { + return BaseURIMutator<T>::InitFromInputStream(aStream); + } + + [[nodiscard]] NS_IMETHOD Finalize(nsIURI** aURI) override { + BaseURIMutator<T>::mURI.forget(aURI); + return NS_OK; + } + + [[nodiscard]] NS_IMETHOD SetSpec(const nsACString& aSpec, + nsIURIMutator** aMutator) override { + if (aMutator) { + nsCOMPtr<nsIURIMutator> mutator = this; + mutator.forget(aMutator); + } + return BaseURIMutator<T>::InitFromSpec(aSpec); + } + + [[nodiscard]] NS_IMETHOD Init(uint32_t aURLType, int32_t aDefaultPort, + const nsACString& aSpec, const char* aCharset, + nsIURI* aBaseURI, + nsIURIMutator** aMutator) override { + if (aMutator) { + nsCOMPtr<nsIURIMutator> mutator = this; + mutator.forget(aMutator); + } + RefPtr<T> uri; + if (BaseURIMutator<T>::mURI) { + // We don't need a new URI object if we already have one + BaseURIMutator<T>::mURI.swap(uri); + } else { + uri = Create(); + } + nsresult rv = + uri->Init(aURLType, aDefaultPort, aSpec, aCharset, aBaseURI); + if (NS_FAILED(rv)) { + return rv; + } + BaseURIMutator<T>::mURI = std::move(uri); + return NS_OK; + } + + [[nodiscard]] NS_IMETHODIMP SetDefaultPort( + int32_t aNewDefaultPort, nsIURIMutator** aMutator) override { + if (!BaseURIMutator<T>::mURI) { + return NS_ERROR_NULL_POINTER; + } + if (aMutator) { + nsCOMPtr<nsIURIMutator> mutator = this; + mutator.forget(aMutator); + } + return BaseURIMutator<T>::mURI->SetDefaultPort(aNewDefaultPort); + } + + [[nodiscard]] NS_IMETHOD SetFileName(const nsACString& aFileName, + nsIURIMutator** aMutator) override { + if (!BaseURIMutator<T>::mURI) { + return NS_ERROR_NULL_POINTER; + } + if (aMutator) { + nsCOMPtr<nsIURIMutator> mutator = this; + mutator.forget(aMutator); + } + return BaseURIMutator<T>::mURI->SetFileNameInternal(aFileName); + } + + [[nodiscard]] NS_IMETHOD SetFileBaseName( + const nsACString& aFileBaseName, nsIURIMutator** aMutator) override { + if (!BaseURIMutator<T>::mURI) { + return NS_ERROR_NULL_POINTER; + } + if (aMutator) { + nsCOMPtr<nsIURIMutator> mutator = this; + mutator.forget(aMutator); + } + return BaseURIMutator<T>::mURI->SetFileBaseNameInternal(aFileBaseName); + } + + [[nodiscard]] NS_IMETHOD SetFileExtension( + const nsACString& aFileExtension, nsIURIMutator** aMutator) override { + if (!BaseURIMutator<T>::mURI) { + return NS_ERROR_NULL_POINTER; + } + if (aMutator) { + nsCOMPtr<nsIURIMutator> mutator = this; + mutator.forget(aMutator); + } + return BaseURIMutator<T>::mURI->SetFileExtensionInternal(aFileExtension); + } + + T* Create() override { return new T(mMarkedFileURL); } + + [[nodiscard]] NS_IMETHOD MarkFileURL() override { + mMarkedFileURL = true; + return NS_OK; + } + + [[nodiscard]] NS_IMETHOD SetFile(nsIFile* aFile) override { + RefPtr<T> uri; + if (BaseURIMutator<T>::mURI) { + // We don't need a new URI object if we already have one + BaseURIMutator<T>::mURI.swap(uri); + } else { + uri = new T(/* aSupportsFileURL = */ true); + } + + nsresult rv = uri->SetFile(aFile); + if (NS_FAILED(rv)) { + return rv; + } + BaseURIMutator<T>::mURI.swap(uri); + return NS_OK; + } + + explicit TemplatedMutator() : mMarkedFileURL(false) {} + + private: + virtual ~TemplatedMutator() = default; + + bool mMarkedFileURL = false; + + friend T; + }; + + class Mutator final : public TemplatedMutator<nsStandardURL> { + NS_DECL_ISUPPORTS + public: + explicit Mutator() = default; + + private: + virtual ~Mutator() = default; + }; + + friend BaseURIMutator<nsStandardURL>; +}; + +#define NS_THIS_STANDARDURL_IMPL_CID \ + { /* b8e3e97b-1ccd-4b45-af5a-79596770f5d7 */ \ + 0xb8e3e97b, 0x1ccd, 0x4b45, { \ + 0xaf, 0x5a, 0x79, 0x59, 0x67, 0x70, 0xf5, 0xd7 \ + } \ + } + +//----------------------------------------------------------------------------- +// Dependent substring getters +//----------------------------------------------------------------------------- + +inline const nsDependentCSubstring nsStandardURL::Segment(uint32_t pos, + int32_t len) { + if (len < 0) { + pos = 0; + len = 0; + } + return Substring(mSpec, pos, uint32_t(len)); +} + +inline const nsDependentCSubstring nsStandardURL::Prepath() { + uint32_t len = 0; + if (mAuthority.mLen >= 0) len = mAuthority.mPos + mAuthority.mLen; + return Substring(mSpec, 0, len); +} + +inline const nsDependentCSubstring nsStandardURL::Userpass(bool includeDelim) { + uint32_t pos = 0, len = 0; + if (mUsername.mLen > 0 || mPassword.mLen > 0) { + if (mUsername.mLen > 0) { + pos = mUsername.mPos; + len = mUsername.mLen; + if (mPassword.mLen >= 0) { + len += (mPassword.mLen + 1); + } + } else { + pos = mPassword.mPos - 1; + len = mPassword.mLen + 1; + } + + if (includeDelim) len++; + } + return Substring(mSpec, pos, len); +} + +inline const nsDependentCSubstring nsStandardURL::Hostport() { + uint32_t pos = 0, len = 0; + if (mAuthority.mLen > 0) { + pos = mHost.mPos; + len = mAuthority.mPos + mAuthority.mLen - pos; + } + return Substring(mSpec, pos, len); +} + +inline const nsDependentCSubstring nsStandardURL::Host() { + uint32_t pos = 0, len = 0; + if (mHost.mLen > 0) { + pos = mHost.mPos; + len = mHost.mLen; + if (mSpec.CharAt(pos) == '[' && mSpec.CharAt(pos + len - 1) == ']') { + pos++; + len -= 2; + } + } + return Substring(mSpec, pos, len); +} + +inline const nsDependentCSubstring nsStandardURL::Filename() { + uint32_t pos = 0, len = 0; + // if there is no basename, then there can be no extension + if (mBasename.mLen > 0) { + pos = mBasename.mPos; + len = mBasename.mLen; + if (mExtension.mLen >= 0) len += (mExtension.mLen + 1); + } + return Substring(mSpec, pos, len); +} + +} // namespace net +} // namespace mozilla + +#endif // nsStandardURL_h__ diff --git a/netwerk/base/nsStreamListenerTee.cpp b/netwerk/base/nsStreamListenerTee.cpp new file mode 100644 index 0000000000..308b21e841 --- /dev/null +++ b/netwerk/base/nsStreamListenerTee.cpp @@ -0,0 +1,157 @@ +/* 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 "nsStreamListenerTee.h" +#include "nsProxyRelease.h" + +namespace mozilla { +namespace net { + +NS_IMPL_ISUPPORTS(nsStreamListenerTee, nsIStreamListener, nsIRequestObserver, + nsIStreamListenerTee, nsIThreadRetargetableStreamListener, + nsIMultiPartChannelListener) + +NS_IMETHODIMP +nsStreamListenerTee::OnStartRequest(nsIRequest* request) { + NS_ENSURE_TRUE(mListener, NS_ERROR_NOT_INITIALIZED); + + nsCOMPtr<nsIMultiPartChannel> multiPartChannel = do_QueryInterface(request); + if (multiPartChannel) { + mIsMultiPart = true; + } + + nsresult rv1 = mListener->OnStartRequest(request); + nsresult rv2 = NS_OK; + if (mObserver) rv2 = mObserver->OnStartRequest(request); + + // Preserve NS_SUCCESS_XXX in rv1 in case mObserver didn't throw + return (NS_FAILED(rv2) && NS_SUCCEEDED(rv1)) ? rv2 : rv1; +} + +NS_IMETHODIMP +nsStreamListenerTee::OnStopRequest(nsIRequest* request, nsresult status) { + NS_ENSURE_TRUE(mListener, NS_ERROR_NOT_INITIALIZED); + // it is critical that we close out the input stream tee + if (mInputTee) { + mInputTee->SetSink(nullptr); + mInputTee = nullptr; + } + + if (!mIsMultiPart) { + // release sink on the same thread where the data was written (bug 716293) + if (mEventTarget) { + NS_ProxyRelease("nsStreamListenerTee::mSink", mEventTarget, + mSink.forget()); + } else { + mSink = nullptr; + } + } + + nsresult rv = mListener->OnStopRequest(request, status); + if (mObserver) mObserver->OnStopRequest(request, status); + if (!mIsMultiPart) { + mObserver = nullptr; + } + return rv; +} + +NS_IMETHODIMP +nsStreamListenerTee::OnDataAvailable(nsIRequest* request, nsIInputStream* input, + uint64_t offset, uint32_t count) { + NS_ENSURE_TRUE(mListener, NS_ERROR_NOT_INITIALIZED); + NS_ENSURE_TRUE(mSink, NS_ERROR_NOT_INITIALIZED); + + nsCOMPtr<nsIInputStream> tee; + nsresult rv; + + if (!mInputTee) { + if (mEventTarget) + rv = NS_NewInputStreamTeeAsync(getter_AddRefs(tee), input, mSink, + mEventTarget); + else + rv = NS_NewInputStreamTee(getter_AddRefs(tee), input, mSink); + if (NS_FAILED(rv)) return rv; + + mInputTee = do_QueryInterface(tee, &rv); + if (NS_FAILED(rv)) return rv; + } else { + // re-initialize the input tee since the input stream may have changed. + rv = mInputTee->SetSource(input); + if (NS_FAILED(rv)) return rv; + + tee = mInputTee; + } + + return mListener->OnDataAvailable(request, tee, offset, count); +} + +NS_IMETHODIMP +nsStreamListenerTee::OnAfterLastPart(nsresult aStatus) { + // release sink on the same thread where the data was written (bug 716293) + if (mEventTarget) { + NS_ProxyRelease("nsStreamListenerTee::mSink", mEventTarget, mSink.forget()); + } else { + mSink = nullptr; + } + + if (nsCOMPtr<nsIMultiPartChannelListener> multi = + do_QueryInterface(mListener)) { + multi->OnAfterLastPart(aStatus); + } + if (!SameCOMIdentity(mListener, mObserver)) { + if (nsCOMPtr<nsIMultiPartChannelListener> multi = + do_QueryInterface(mObserver)) { + multi->OnAfterLastPart(aStatus); + } + } + + mObserver = nullptr; + return NS_OK; +} + +NS_IMETHODIMP +nsStreamListenerTee::CheckListenerChain() { + NS_ASSERTION(NS_IsMainThread(), "Should be on main thread!"); + nsresult rv = NS_OK; + nsCOMPtr<nsIThreadRetargetableStreamListener> retargetableListener = + do_QueryInterface(mListener, &rv); + if (retargetableListener) { + rv = retargetableListener->CheckListenerChain(); + } + if (NS_FAILED(rv)) { + return rv; + } + if (!mObserver) { + return rv; + } + retargetableListener = do_QueryInterface(mObserver, &rv); + if (retargetableListener) { + rv = retargetableListener->CheckListenerChain(); + } + return rv; +} + +NS_IMETHODIMP +nsStreamListenerTee::Init(nsIStreamListener* listener, nsIOutputStream* sink, + nsIRequestObserver* requestObserver) { + NS_ENSURE_ARG_POINTER(listener); + NS_ENSURE_ARG_POINTER(sink); + mListener = listener; + mSink = sink; + mObserver = requestObserver; + return NS_OK; +} + +NS_IMETHODIMP +nsStreamListenerTee::InitAsync(nsIStreamListener* listener, + nsIEventTarget* eventTarget, + nsIOutputStream* sink, + nsIRequestObserver* requestObserver) { + NS_ENSURE_ARG_POINTER(eventTarget); + mEventTarget = eventTarget; + return Init(listener, sink, requestObserver); +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/nsStreamListenerTee.h b/netwerk/base/nsStreamListenerTee.h new file mode 100644 index 0000000000..0b54bbf5dd --- /dev/null +++ b/netwerk/base/nsStreamListenerTee.h @@ -0,0 +1,46 @@ +/* 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/. */ + +#ifndef nsStreamListenerTee_h__ +#define nsStreamListenerTee_h__ + +#include "nsIStreamListenerTee.h" +#include "nsIThreadRetargetableStreamListener.h" +#include "nsIInputStreamTee.h" +#include "nsIOutputStream.h" +#include "nsCOMPtr.h" +#include "nsIEventTarget.h" +#include "nsIMultiPartChannel.h" + +namespace mozilla { +namespace net { + +class nsStreamListenerTee : public nsIStreamListenerTee, + public nsIThreadRetargetableStreamListener, + public nsIMultiPartChannelListener { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIREQUESTOBSERVER + NS_DECL_NSISTREAMLISTENER + NS_DECL_NSITHREADRETARGETABLESTREAMLISTENER + NS_DECL_NSISTREAMLISTENERTEE + NS_DECL_NSIMULTIPARTCHANNELLISTENER + + nsStreamListenerTee() = default; + + private: + virtual ~nsStreamListenerTee() = default; + + nsCOMPtr<nsIInputStreamTee> mInputTee; + nsCOMPtr<nsIOutputStream> mSink; + nsCOMPtr<nsIStreamListener> mListener; + nsCOMPtr<nsIRequestObserver> mObserver; + nsCOMPtr<nsIEventTarget> mEventTarget; + bool mIsMultiPart = false; +}; + +} // namespace net +} // namespace mozilla + +#endif diff --git a/netwerk/base/nsStreamListenerWrapper.cpp b/netwerk/base/nsStreamListenerWrapper.cpp new file mode 100644 index 0000000000..d72a5c66e4 --- /dev/null +++ b/netwerk/base/nsStreamListenerWrapper.cpp @@ -0,0 +1,39 @@ +/* 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 "nsStreamListenerWrapper.h" +#ifdef DEBUG +# include "MainThreadUtils.h" +#endif + +namespace mozilla { +namespace net { + +NS_IMPL_ISUPPORTS(nsStreamListenerWrapper, nsIStreamListener, + nsIRequestObserver, nsIMultiPartChannelListener, + nsIThreadRetargetableStreamListener) + +NS_IMETHODIMP +nsStreamListenerWrapper::OnAfterLastPart(nsresult aStatus) { + if (nsCOMPtr<nsIMultiPartChannelListener> listener = + do_QueryInterface(mListener)) { + return listener->OnAfterLastPart(aStatus); + } + return NS_OK; +} + +NS_IMETHODIMP +nsStreamListenerWrapper::CheckListenerChain() { + NS_ASSERTION(NS_IsMainThread(), "Should be on main thread!"); + nsresult rv = NS_OK; + nsCOMPtr<nsIThreadRetargetableStreamListener> retargetableListener = + do_QueryInterface(mListener, &rv); + if (retargetableListener) { + rv = retargetableListener->CheckListenerChain(); + } + return rv; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/nsStreamListenerWrapper.h b/netwerk/base/nsStreamListenerWrapper.h new file mode 100644 index 0000000000..9871adf71c --- /dev/null +++ b/netwerk/base/nsStreamListenerWrapper.h @@ -0,0 +1,43 @@ +/* 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/. */ + +#ifndef nsStreamListenerWrapper_h__ +#define nsStreamListenerWrapper_h__ + +#include "nsCOMPtr.h" +#include "nsIStreamListener.h" +#include "nsIThreadRetargetableStreamListener.h" +#include "nsIMultiPartChannel.h" +#include "mozilla/Attributes.h" + +namespace mozilla { +namespace net { + +// Wrapper class to make replacement of nsHttpChannel's listener +// from JavaScript possible. It is workaround for bug 433711 and 682305. +class nsStreamListenerWrapper final + : public nsIStreamListener, + public nsIMultiPartChannelListener, + public nsIThreadRetargetableStreamListener { + public: + explicit nsStreamListenerWrapper(nsIStreamListener* listener) + : mListener(listener) { + MOZ_ASSERT(mListener, "no stream listener specified"); + } + + NS_DECL_THREADSAFE_ISUPPORTS + NS_FORWARD_SAFE_NSIREQUESTOBSERVER(mListener) + NS_FORWARD_SAFE_NSISTREAMLISTENER(mListener) + NS_DECL_NSIMULTIPARTCHANNELLISTENER + NS_DECL_NSITHREADRETARGETABLESTREAMLISTENER + + private: + ~nsStreamListenerWrapper() = default; + nsCOMPtr<nsIStreamListener> mListener; +}; + +} // namespace net +} // namespace mozilla + +#endif // nsStreamListenerWrapper_h__ diff --git a/netwerk/base/nsStreamLoader.cpp b/netwerk/base/nsStreamLoader.cpp new file mode 100644 index 0000000000..e72384d903 --- /dev/null +++ b/netwerk/base/nsStreamLoader.cpp @@ -0,0 +1,140 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "nsStreamLoader.h" +#include "nsIInputStream.h" +#include "nsIChannel.h" +#include "nsError.h" +#include "GeckoProfiler.h" + +#include <limits> + +namespace mozilla { +namespace net { + +nsStreamLoader::nsStreamLoader() : mData() {} + +NS_IMETHODIMP +nsStreamLoader::Init(nsIStreamLoaderObserver* aStreamObserver, + nsIRequestObserver* aRequestObserver) { + NS_ENSURE_ARG_POINTER(aStreamObserver); + mObserver = aStreamObserver; + mRequestObserver = aRequestObserver; + return NS_OK; +} + +nsresult nsStreamLoader::Create(nsISupports* aOuter, REFNSIID aIID, + void** aResult) { + if (aOuter) return NS_ERROR_NO_AGGREGATION; + + RefPtr<nsStreamLoader> it = new nsStreamLoader(); + return it->QueryInterface(aIID, aResult); +} + +NS_IMPL_ISUPPORTS(nsStreamLoader, nsIStreamLoader, nsIRequestObserver, + nsIStreamListener, nsIThreadRetargetableStreamListener) + +NS_IMETHODIMP +nsStreamLoader::GetNumBytesRead(uint32_t* aNumBytes) { + *aNumBytes = mBytesRead; + return NS_OK; +} + +NS_IMETHODIMP +nsStreamLoader::GetRequest(nsIRequest** aRequest) { + nsCOMPtr<nsIRequest> req = mRequest; + req.forget(aRequest); + return NS_OK; +} + +NS_IMETHODIMP +nsStreamLoader::OnStartRequest(nsIRequest* request) { + nsCOMPtr<nsIChannel> chan(do_QueryInterface(request)); + if (chan) { + int64_t contentLength = -1; + chan->GetContentLength(&contentLength); + if (contentLength >= 0) { + // On 64bit platforms size of uint64_t coincides with the size of size_t, + // so we want to compare with the minimum from size_t and int64_t. + if (static_cast<uint64_t>(contentLength) > + std::min(std::numeric_limits<size_t>::max(), + static_cast<size_t>(std::numeric_limits<int64_t>::max()))) { + // Too big to fit into size_t, so let's bail. + return NS_ERROR_OUT_OF_MEMORY; + } + // preallocate buffer + if (!mData.initCapacity(contentLength)) { + return NS_ERROR_OUT_OF_MEMORY; + } + } + } + if (mRequestObserver) { + mRequestObserver->OnStartRequest(request); + } + return NS_OK; +} + +NS_IMETHODIMP +nsStreamLoader::OnStopRequest(nsIRequest* request, nsresult aStatus) { + AUTO_PROFILER_LABEL("nsStreamLoader::OnStopRequest", NETWORK); + + if (mObserver) { + // provide nsIStreamLoader::request during call to OnStreamComplete + mRequest = request; + size_t length = mData.length(); + uint8_t* elems = mData.extractOrCopyRawBuffer(); + nsresult rv = + mObserver->OnStreamComplete(this, mContext, aStatus, length, elems); + if (rv != NS_SUCCESS_ADOPTED_DATA) { + // The observer didn't take ownership of the extracted data buffer, so + // put it back into mData. + mData.replaceRawBuffer(elems, length); + } + // done.. cleanup + ReleaseData(); + mRequest = nullptr; + mObserver = nullptr; + } + + if (mRequestObserver) { + mRequestObserver->OnStopRequest(request, aStatus); + mRequestObserver = nullptr; + } + + return NS_OK; +} + +nsresult nsStreamLoader::WriteSegmentFun(nsIInputStream* inStr, void* closure, + const char* fromSegment, + uint32_t toOffset, uint32_t count, + uint32_t* writeCount) { + nsStreamLoader* self = (nsStreamLoader*)closure; + + if (!self->mData.append(fromSegment, count)) { + self->mData.clearAndFree(); + return NS_ERROR_OUT_OF_MEMORY; + } + + *writeCount = count; + return NS_OK; +} + +NS_IMETHODIMP +nsStreamLoader::OnDataAvailable(nsIRequest* request, nsIInputStream* inStr, + uint64_t sourceOffset, uint32_t count) { + uint32_t countRead; + nsresult rv = inStr->ReadSegments(WriteSegmentFun, this, count, &countRead); + NS_ENSURE_SUCCESS(rv, rv); + mBytesRead += countRead; + return NS_OK; +} + +void nsStreamLoader::ReleaseData() { mData.clearAndFree(); } + +NS_IMETHODIMP +nsStreamLoader::CheckListenerChain() { return NS_OK; } + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/nsStreamLoader.h b/netwerk/base/nsStreamLoader.h new file mode 100644 index 0000000000..645260644c --- /dev/null +++ b/netwerk/base/nsStreamLoader.h @@ -0,0 +1,58 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef nsStreamLoader_h__ +#define nsStreamLoader_h__ + +#include "nsIThreadRetargetableStreamListener.h" +#include "nsIStreamLoader.h" +#include "nsCOMPtr.h" +#include "mozilla/Attributes.h" +#include "mozilla/Vector.h" + +class nsIRequest; + +namespace mozilla { +namespace net { + +class nsStreamLoader final : public nsIStreamLoader, + public nsIThreadRetargetableStreamListener { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSISTREAMLOADER + NS_DECL_NSIREQUESTOBSERVER + NS_DECL_NSISTREAMLISTENER + NS_DECL_NSITHREADRETARGETABLESTREAMLISTENER + + nsStreamLoader(); + + static nsresult Create(nsISupports* aOuter, REFNSIID aIID, void** aResult); + + protected: + ~nsStreamLoader() = default; + + static nsresult WriteSegmentFun(nsIInputStream*, void*, const char*, uint32_t, + uint32_t, uint32_t*); + + // Utility method to free mData, if present, and update other state to + // reflect that no data has been allocated. + void ReleaseData(); + + nsCOMPtr<nsIStreamLoaderObserver> mObserver; + nsCOMPtr<nsISupports> mContext; // the observer's context + nsCOMPtr<nsIRequest> mRequest; + nsCOMPtr<nsIRequestObserver> mRequestObserver; + + mozilla::Atomic<uint32_t, mozilla::MemoryOrdering::Relaxed> mBytesRead; + + // Buffer to accumulate incoming data. We preallocate if contentSize is + // available. + mozilla::Vector<uint8_t, 0> mData; +}; + +} // namespace net +} // namespace mozilla + +#endif // nsStreamLoader_h__ diff --git a/netwerk/base/nsStreamTransportService.cpp b/netwerk/base/nsStreamTransportService.cpp new file mode 100644 index 0000000000..8a528df2d6 --- /dev/null +++ b/netwerk/base/nsStreamTransportService.cpp @@ -0,0 +1,408 @@ +/* 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 "nsStreamTransportService.h" +#include "nsXPCOMCIDInternal.h" +#include "nsNetSegmentUtils.h" +#include "nsTransportUtils.h" +#include "nsStreamUtils.h" +#include "nsError.h" +#include "nsNetCID.h" + +#include "nsIAsyncInputStream.h" +#include "nsIAsyncOutputStream.h" +#include "nsIPipe.h" +#include "nsITransport.h" +#include "nsIObserverService.h" +#include "nsThreadPool.h" +#include "mozilla/Services.h" + +namespace mozilla { +namespace net { + +//----------------------------------------------------------------------------- +// nsInputStreamTransport +// +// Implements nsIInputStream as a wrapper around the real input stream. This +// allows the transport to support seeking, range-limiting, progress reporting, +// and close-when-done semantics while utilizing NS_AsyncCopy. +//----------------------------------------------------------------------------- + +class nsInputStreamTransport : public nsITransport, + public nsIAsyncInputStream, + public nsIInputStreamCallback { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSITRANSPORT + NS_DECL_NSIINPUTSTREAM + NS_DECL_NSIASYNCINPUTSTREAM + NS_DECL_NSIINPUTSTREAMCALLBACK + + nsInputStreamTransport(nsIInputStream* source, bool closeWhenDone) + : mMutex("nsInputStreamTransport::mMutex"), + mSource(source), + mOffset(0), + mCloseWhenDone(closeWhenDone), + mInProgress(false) { + mAsyncSource = do_QueryInterface(mSource); + } + + private: + virtual ~nsInputStreamTransport() = default; + + Mutex mMutex; + + // This value is protected by mutex. + nsCOMPtr<nsIInputStreamCallback> mAsyncWaitCallback; + + nsCOMPtr<nsIAsyncInputStream> mPipeIn; + + // while the copy is active, these members may only be accessed from the + // nsIInputStream implementation. + nsCOMPtr<nsITransportEventSink> mEventSink; + nsCOMPtr<nsIInputStream> mSource; + + // It can be null. + nsCOMPtr<nsIAsyncInputStream> mAsyncSource; + + int64_t mOffset; + const bool mCloseWhenDone; + + // this variable serves as a lock to prevent the state of the transport + // from being modified once the copy is in progress. + bool mInProgress; +}; + +NS_IMPL_ADDREF(nsInputStreamTransport); +NS_IMPL_RELEASE(nsInputStreamTransport); + +NS_INTERFACE_MAP_BEGIN(nsInputStreamTransport) + NS_INTERFACE_MAP_ENTRY(nsITransport) + NS_INTERFACE_MAP_ENTRY(nsIInputStream) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAsyncInputStream, !!mAsyncSource) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIInputStreamCallback, !!mAsyncSource) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsITransport) +NS_INTERFACE_MAP_END + +/** nsITransport **/ + +NS_IMETHODIMP +nsInputStreamTransport::OpenInputStream(uint32_t flags, uint32_t segsize, + uint32_t segcount, + nsIInputStream** result) { + NS_ENSURE_TRUE(!mInProgress, NS_ERROR_IN_PROGRESS); + + nsresult rv; + nsCOMPtr<nsIEventTarget> target = + do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID, &rv); + if (NS_FAILED(rv)) return rv; + + // XXX if the caller requests an unbuffered stream, then perhaps + // we'd want to simply return mSource; however, then we would + // not be reading mSource on a background thread. is this ok? + + bool nonblocking = !(flags & OPEN_BLOCKING); + + net_ResolveSegmentParams(segsize, segcount); + + nsCOMPtr<nsIAsyncOutputStream> pipeOut; + rv = NS_NewPipe2(getter_AddRefs(mPipeIn), getter_AddRefs(pipeOut), + nonblocking, true, segsize, segcount); + if (NS_FAILED(rv)) return rv; + + mInProgress = true; + + // startup async copy process... + rv = NS_AsyncCopy(this, pipeOut, target, NS_ASYNCCOPY_VIA_WRITESEGMENTS, + segsize); + if (NS_FAILED(rv)) { + return rv; + } + *result = do_AddRef(mPipeIn).take(); + return NS_OK; +} + +NS_IMETHODIMP +nsInputStreamTransport::OpenOutputStream(uint32_t flags, uint32_t segsize, + uint32_t segcount, + nsIOutputStream** result) { + // this transport only supports reading! + MOZ_ASSERT_UNREACHABLE("nsInputStreamTransport::OpenOutputStream"); + return NS_ERROR_UNEXPECTED; +} + +NS_IMETHODIMP +nsInputStreamTransport::Close(nsresult reason) { + if (NS_SUCCEEDED(reason)) reason = NS_BASE_STREAM_CLOSED; + + return mPipeIn->CloseWithStatus(reason); +} + +NS_IMETHODIMP +nsInputStreamTransport::SetEventSink(nsITransportEventSink* sink, + nsIEventTarget* target) { + NS_ENSURE_TRUE(!mInProgress, NS_ERROR_IN_PROGRESS); + + if (target) + return net_NewTransportEventSinkProxy(getter_AddRefs(mEventSink), sink, + target); + + mEventSink = sink; + return NS_OK; +} + +/** nsIInputStream **/ + +NS_IMETHODIMP +nsInputStreamTransport::Close() { + if (mCloseWhenDone) mSource->Close(); + + // make additional reads return early... + mOffset = 0; + return NS_OK; +} + +NS_IMETHODIMP +nsInputStreamTransport::Available(uint64_t* result) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsInputStreamTransport::Read(char* buf, uint32_t count, uint32_t* result) { + nsresult rv = mSource->Read(buf, count, result); + + if (NS_SUCCEEDED(rv)) { + mOffset += *result; + if (mEventSink) + mEventSink->OnTransportStatus(this, NS_NET_STATUS_READING, mOffset, -1); + } + return rv; +} + +NS_IMETHODIMP +nsInputStreamTransport::ReadSegments(nsWriteSegmentFun writer, void* closure, + uint32_t count, uint32_t* result) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsInputStreamTransport::IsNonBlocking(bool* result) { + *result = false; + return NS_OK; +} + +// nsIAsyncInputStream interface + +NS_IMETHODIMP +nsInputStreamTransport::CloseWithStatus(nsresult aStatus) { return Close(); } + +NS_IMETHODIMP +nsInputStreamTransport::AsyncWait(nsIInputStreamCallback* aCallback, + uint32_t aFlags, uint32_t aRequestedCount, + nsIEventTarget* aEventTarget) { + NS_ENSURE_STATE(!!mAsyncSource); + + nsCOMPtr<nsIInputStreamCallback> callback = aCallback ? this : nullptr; + + { + MutexAutoLock lock(mMutex); + + if (mAsyncWaitCallback && aCallback) { + return NS_ERROR_FAILURE; + } + + mAsyncWaitCallback = aCallback; + } + + return mAsyncSource->AsyncWait(callback, aFlags, aRequestedCount, + aEventTarget); +} + +// nsIInputStreamCallback + +NS_IMETHODIMP +nsInputStreamTransport::OnInputStreamReady(nsIAsyncInputStream* aStream) { + nsCOMPtr<nsIInputStreamCallback> callback; + { + MutexAutoLock lock(mMutex); + + // We have been canceled in the meanwhile. + if (!mAsyncWaitCallback) { + return NS_OK; + } + + callback.swap(mAsyncWaitCallback); + } + + MOZ_ASSERT(callback); + return callback->OnInputStreamReady(this); +} + +//----------------------------------------------------------------------------- +// nsStreamTransportService +//----------------------------------------------------------------------------- + +nsStreamTransportService::~nsStreamTransportService() { + NS_ASSERTION(!mPool, "thread pool wasn't shutdown"); +} + +nsresult nsStreamTransportService::Init() { + mPool = new nsThreadPool(); + + // Configure the pool + mPool->SetName("StreamTrans"_ns); + mPool->SetThreadLimit(25); + mPool->SetIdleThreadLimit(5); + mPool->SetIdleThreadTimeoutRegressive(true); + mPool->SetIdleThreadTimeout(PR_SecondsToInterval(30)); + + nsCOMPtr<nsIObserverService> obsSvc = mozilla::services::GetObserverService(); + if (obsSvc) obsSvc->AddObserver(this, "xpcom-shutdown-threads", false); + return NS_OK; +} + +NS_IMPL_ISUPPORTS(nsStreamTransportService, nsIStreamTransportService, + nsIEventTarget, nsIObserver) + +NS_IMETHODIMP +nsStreamTransportService::DispatchFromScript(nsIRunnable* task, + uint32_t flags) { + nsCOMPtr<nsIRunnable> event(task); + return Dispatch(event.forget(), flags); +} + +NS_IMETHODIMP +nsStreamTransportService::Dispatch(already_AddRefed<nsIRunnable> task, + uint32_t flags) { + nsCOMPtr<nsIRunnable> event(task); // so it gets released on failure paths + nsCOMPtr<nsIThreadPool> pool; + { + mozilla::MutexAutoLock lock(mShutdownLock); + if (mIsShutdown) { + return NS_ERROR_NOT_INITIALIZED; + } + pool = mPool; + } + NS_ENSURE_TRUE(pool, NS_ERROR_NOT_INITIALIZED); + return pool->Dispatch(event.forget(), flags); +} + +NS_IMETHODIMP +nsStreamTransportService::DelayedDispatch(already_AddRefed<nsIRunnable>, + uint32_t) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP_(bool) +nsStreamTransportService::IsOnCurrentThreadInfallible() { + nsCOMPtr<nsIThreadPool> pool; + { + mozilla::MutexAutoLock lock(mShutdownLock); + pool = mPool; + } + if (!pool) { + return false; + } + return pool->IsOnCurrentThread(); +} + +NS_IMETHODIMP +nsStreamTransportService::IsOnCurrentThread(bool* result) { + nsCOMPtr<nsIThreadPool> pool; + { + mozilla::MutexAutoLock lock(mShutdownLock); + if (mIsShutdown) { + return NS_ERROR_NOT_INITIALIZED; + } + pool = mPool; + } + NS_ENSURE_TRUE(pool, NS_ERROR_NOT_INITIALIZED); + return pool->IsOnCurrentThread(result); +} + +NS_IMETHODIMP +nsStreamTransportService::CreateInputTransport(nsIInputStream* stream, + bool closeWhenDone, + nsITransport** result) { + RefPtr<nsInputStreamTransport> trans = + new nsInputStreamTransport(stream, closeWhenDone); + trans.forget(result); + return NS_OK; +} + +NS_IMETHODIMP +nsStreamTransportService::Observe(nsISupports* subject, const char* topic, + const char16_t* data) { + NS_ASSERTION(strcmp(topic, "xpcom-shutdown-threads") == 0, "oops"); + + { + mozilla::MutexAutoLock lock(mShutdownLock); + mIsShutdown = true; + } + + if (mPool) { + mPool->Shutdown(); + mPool = nullptr; + } + return NS_OK; +} + +class AvailableEvent final : public Runnable { + public: + AvailableEvent(nsIInputStream* stream, nsIInputAvailableCallback* callback) + : Runnable("net::AvailableEvent"), + mStream(stream), + mCallback(callback), + mDoingCallback(false), + mSize(0), + mResultForCallback(NS_OK) { + mCallbackTarget = GetCurrentEventTarget(); + } + + NS_IMETHOD Run() override { + if (mDoingCallback) { + // pong + mCallback->OnInputAvailableComplete(mSize, mResultForCallback); + mCallback = nullptr; + } else { + // ping + mResultForCallback = mStream->Available(&mSize); + mStream = nullptr; + mDoingCallback = true; + + nsCOMPtr<nsIRunnable> event(this); // overly cute + mCallbackTarget->Dispatch(event.forget(), NS_DISPATCH_NORMAL); + mCallbackTarget = nullptr; + } + return NS_OK; + } + + private: + virtual ~AvailableEvent() = default; + + nsCOMPtr<nsIInputStream> mStream; + nsCOMPtr<nsIInputAvailableCallback> mCallback; + nsCOMPtr<nsIEventTarget> mCallbackTarget; + bool mDoingCallback; + uint64_t mSize; + nsresult mResultForCallback; +}; + +NS_IMETHODIMP +nsStreamTransportService::InputAvailable(nsIInputStream* stream, + nsIInputAvailableCallback* callback) { + nsCOMPtr<nsIThreadPool> pool; + { + mozilla::MutexAutoLock lock(mShutdownLock); + if (mIsShutdown) { + return NS_ERROR_NOT_INITIALIZED; + } + pool = mPool; + } + nsCOMPtr<nsIRunnable> event = new AvailableEvent(stream, callback); + return pool->Dispatch(event.forget(), NS_DISPATCH_NORMAL); +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/nsStreamTransportService.h b/netwerk/base/nsStreamTransportService.h new file mode 100644 index 0000000000..187db4f87c --- /dev/null +++ b/netwerk/base/nsStreamTransportService.h @@ -0,0 +1,47 @@ +/* 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/. */ + +#ifndef nsStreamTransportService_h__ +#define nsStreamTransportService_h__ + +#include "nsIStreamTransportService.h" +#include "nsIEventTarget.h" +#include "nsIObserver.h" +#include "nsCOMPtr.h" +#include "nsThreadUtils.h" +#include "mozilla/Attributes.h" +#include "mozilla/Mutex.h" + +class nsIThreadPool; + +namespace mozilla { +namespace net { + +class nsStreamTransportService final : public nsIStreamTransportService, + public nsIEventTarget, + public nsIObserver { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSISTREAMTRANSPORTSERVICE + NS_DECL_NSIEVENTTARGET_FULL + NS_DECL_NSIOBSERVER + + nsresult Init(); + + nsStreamTransportService() + : mShutdownLock("nsStreamTransportService.mShutdownLock"), + mIsShutdown(false) {} + + private: + ~nsStreamTransportService(); + + nsCOMPtr<nsIThreadPool> mPool; + + mozilla::Mutex mShutdownLock; + bool mIsShutdown; +}; + +} // namespace net +} // namespace mozilla +#endif diff --git a/netwerk/base/nsSyncStreamListener.cpp b/netwerk/base/nsSyncStreamListener.cpp new file mode 100644 index 0000000000..9bfcd63d67 --- /dev/null +++ b/netwerk/base/nsSyncStreamListener.cpp @@ -0,0 +1,167 @@ +/* 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 "mozilla/SpinEventLoopUntil.h" +#include "nsIOService.h" +#include "nsSyncStreamListener.h" +#include "nsThreadUtils.h" +#include <algorithm> + +using namespace mozilla::net; + +nsresult nsSyncStreamListener::Init() { + return NS_NewPipe(getter_AddRefs(mPipeIn), getter_AddRefs(mPipeOut), + mozilla::net::nsIOService::gDefaultSegmentSize, + UINT32_MAX, // no size limit + false, false); +} + +// static +already_AddRefed<nsISyncStreamListener> nsSyncStreamListener::Create() { + MOZ_ASSERT(NS_IsMainThread()); + + RefPtr<nsSyncStreamListener> inst = new nsSyncStreamListener(); + nsresult rv = inst->Init(); + NS_ENSURE_SUCCESS(rv, nullptr); + + return inst.forget(); +} + +nsresult nsSyncStreamListener::WaitForData() { + mKeepWaiting = true; + + if (!mozilla::SpinEventLoopUntil([&]() { return !mKeepWaiting; })) { + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +//----------------------------------------------------------------------------- +// nsSyncStreamListener::nsISupports +//----------------------------------------------------------------------------- + +NS_IMPL_ISUPPORTS(nsSyncStreamListener, nsIStreamListener, nsIRequestObserver, + nsIInputStream, nsISyncStreamListener) + +//----------------------------------------------------------------------------- +// nsSyncStreamListener::nsISyncStreamListener +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +nsSyncStreamListener::GetInputStream(nsIInputStream** result) { + *result = do_AddRef(this).take(); + return NS_OK; +} + +//----------------------------------------------------------------------------- +// nsSyncStreamListener::nsIStreamListener +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +nsSyncStreamListener::OnStartRequest(nsIRequest* request) { return NS_OK; } + +NS_IMETHODIMP +nsSyncStreamListener::OnDataAvailable(nsIRequest* request, + nsIInputStream* stream, uint64_t offset, + uint32_t count) { + uint32_t bytesWritten; + + nsresult rv = mPipeOut->WriteFrom(stream, count, &bytesWritten); + + // if we get an error, then return failure. this will cause the + // channel to be canceled, and as a result our OnStopRequest method + // will be called immediately. because of this we do not need to + // set mStatus or mKeepWaiting here. + if (NS_FAILED(rv)) return rv; + + // we expect that all data will be written to the pipe because + // the pipe was created to have "infinite" room. + NS_ASSERTION(bytesWritten == count, "did not write all data"); + + mKeepWaiting = false; // unblock Read + return NS_OK; +} + +NS_IMETHODIMP +nsSyncStreamListener::OnStopRequest(nsIRequest* request, nsresult status) { + mStatus = status; + mKeepWaiting = false; // unblock Read + mDone = true; + return NS_OK; +} + +//----------------------------------------------------------------------------- +// nsSyncStreamListener::nsIInputStream +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +nsSyncStreamListener::Close() { + mStatus = NS_BASE_STREAM_CLOSED; + mDone = true; + + // It'd be nice if we could explicitly cancel the request at this point, + // but we don't have a reference to it, so the best we can do is close the + // pipe so that the next OnDataAvailable event will fail. + if (mPipeIn) { + mPipeIn->Close(); + mPipeIn = nullptr; + } + return NS_OK; +} + +NS_IMETHODIMP +nsSyncStreamListener::Available(uint64_t* result) { + if (NS_FAILED(mStatus)) return mStatus; + + mStatus = mPipeIn->Available(result); + if (NS_SUCCEEDED(mStatus) && (*result == 0) && !mDone) { + nsresult rv = WaitForData(); + if (NS_FAILED(rv)) { + // Note that `WaitForData` could fail `mStatus`. Do not overwrite if it's + // the case. + mStatus = NS_SUCCEEDED(mStatus) ? rv : mStatus; + } else if (NS_SUCCEEDED(mStatus)) { + mStatus = mPipeIn->Available(result); + } + } + return mStatus; +} + +NS_IMETHODIMP +nsSyncStreamListener::Read(char* buf, uint32_t bufLen, uint32_t* result) { + if (mStatus == NS_BASE_STREAM_CLOSED) { + *result = 0; + return NS_OK; + } + + uint64_t avail64; + if (NS_FAILED(Available(&avail64))) return mStatus; + + uint32_t avail = (uint32_t)std::min(avail64, (uint64_t)bufLen); + mStatus = mPipeIn->Read(buf, avail, result); + return mStatus; +} + +NS_IMETHODIMP +nsSyncStreamListener::ReadSegments(nsWriteSegmentFun writer, void* closure, + uint32_t count, uint32_t* result) { + if (mStatus == NS_BASE_STREAM_CLOSED) { + *result = 0; + return NS_OK; + } + + uint64_t avail64; + if (NS_FAILED(Available(&avail64))) return mStatus; + + uint32_t avail = (uint32_t)std::min(avail64, (uint64_t)count); + mStatus = mPipeIn->ReadSegments(writer, closure, avail, result); + return mStatus; +} + +NS_IMETHODIMP +nsSyncStreamListener::IsNonBlocking(bool* result) { + *result = false; + return NS_OK; +} diff --git a/netwerk/base/nsSyncStreamListener.h b/netwerk/base/nsSyncStreamListener.h new file mode 100644 index 0000000000..8ed2b5c21a --- /dev/null +++ b/netwerk/base/nsSyncStreamListener.h @@ -0,0 +1,42 @@ +/* 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/. */ + +#ifndef nsSyncStreamListener_h__ +#define nsSyncStreamListener_h__ + +#include "nsISyncStreamListener.h" +#include "nsIInputStream.h" +#include "nsIOutputStream.h" +#include "nsCOMPtr.h" +#include "mozilla/Attributes.h" + +//----------------------------------------------------------------------------- + +class nsSyncStreamListener final : public nsISyncStreamListener, + public nsIInputStream { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIREQUESTOBSERVER + NS_DECL_NSISTREAMLISTENER + NS_DECL_NSISYNCSTREAMLISTENER + NS_DECL_NSIINPUTSTREAM + + static already_AddRefed<nsISyncStreamListener> Create(); + + private: + nsSyncStreamListener() : mStatus(NS_OK), mKeepWaiting(false), mDone(false) {} + ~nsSyncStreamListener() = default; + + nsresult Init(); + + nsresult WaitForData(); + + nsCOMPtr<nsIInputStream> mPipeIn; + nsCOMPtr<nsIOutputStream> mPipeOut; + nsresult mStatus; + bool mKeepWaiting; + bool mDone; +}; + +#endif // nsSyncStreamListener_h__ diff --git a/netwerk/base/nsTransportUtils.cpp b/netwerk/base/nsTransportUtils.cpp new file mode 100644 index 0000000000..4b965a4fdb --- /dev/null +++ b/netwerk/base/nsTransportUtils.cpp @@ -0,0 +1,126 @@ +/* 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 "mozilla/Mutex.h" +#include "nsTransportUtils.h" +#include "nsITransport.h" +#include "nsProxyRelease.h" +#include "nsThreadUtils.h" +#include "nsCOMPtr.h" + +using namespace mozilla; + +//----------------------------------------------------------------------------- + +class nsTransportStatusEvent; + +class nsTransportEventSinkProxy : public nsITransportEventSink { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSITRANSPORTEVENTSINK + + nsTransportEventSinkProxy(nsITransportEventSink* sink, nsIEventTarget* target) + : mSink(sink), + mTarget(target), + mLock("nsTransportEventSinkProxy.mLock"), + mLastEvent(nullptr) { + NS_ADDREF(mSink); + } + + private: + virtual ~nsTransportEventSinkProxy() { + // our reference to mSink could be the last, so be sure to release + // it on the target thread. otherwise, we could get into trouble. + NS_ProxyRelease("nsTransportEventSinkProxy::mSink", mTarget, + dont_AddRef(mSink)); + } + + public: + nsITransportEventSink* mSink; + nsCOMPtr<nsIEventTarget> mTarget; + Mutex mLock; + nsTransportStatusEvent* mLastEvent; +}; + +class nsTransportStatusEvent : public Runnable { + public: + nsTransportStatusEvent(nsTransportEventSinkProxy* proxy, + nsITransport* transport, nsresult status, + int64_t progress, int64_t progressMax) + : Runnable("nsTransportStatusEvent"), + mProxy(proxy), + mTransport(transport), + mStatus(status), + mProgress(progress), + mProgressMax(progressMax) {} + + ~nsTransportStatusEvent() = default; + + NS_IMETHOD Run() override { + // since this event is being handled, we need to clear the proxy's ref. + // if not coalescing all, then last event may not equal self! + { + MutexAutoLock lock(mProxy->mLock); + if (mProxy->mLastEvent == this) mProxy->mLastEvent = nullptr; + } + + mProxy->mSink->OnTransportStatus(mTransport, mStatus, mProgress, + mProgressMax); + return NS_OK; + } + + RefPtr<nsTransportEventSinkProxy> mProxy; + + // parameters to OnTransportStatus + nsCOMPtr<nsITransport> mTransport; + nsresult mStatus; + int64_t mProgress; + int64_t mProgressMax; +}; + +NS_IMPL_ISUPPORTS(nsTransportEventSinkProxy, nsITransportEventSink) + +NS_IMETHODIMP +nsTransportEventSinkProxy::OnTransportStatus(nsITransport* transport, + nsresult status, int64_t progress, + int64_t progressMax) { + nsresult rv = NS_OK; + RefPtr<nsTransportStatusEvent> event; + { + MutexAutoLock lock(mLock); + + // try to coalesce events! ;-) + if (mLastEvent && (mLastEvent->mStatus == status)) { + mLastEvent->mStatus = status; + mLastEvent->mProgress = progress; + mLastEvent->mProgressMax = progressMax; + } else { + event = new nsTransportStatusEvent(this, transport, status, progress, + progressMax); + if (!event) rv = NS_ERROR_OUT_OF_MEMORY; + mLastEvent = event; // weak ref + } + } + if (event) { + rv = mTarget->Dispatch(event, NS_DISPATCH_NORMAL); + if (NS_FAILED(rv)) { + NS_WARNING("unable to post transport status event"); + + MutexAutoLock lock(mLock); // cleanup.. don't reference anymore! + mLastEvent = nullptr; + } + } + return rv; +} + +//----------------------------------------------------------------------------- + +nsresult net_NewTransportEventSinkProxy(nsITransportEventSink** result, + nsITransportEventSink* sink, + nsIEventTarget* target) { + RefPtr<nsTransportEventSinkProxy> res = + new nsTransportEventSinkProxy(sink, target); + res.forget(result); + return NS_OK; +} diff --git a/netwerk/base/nsTransportUtils.h b/netwerk/base/nsTransportUtils.h new file mode 100644 index 0000000000..141b9e4eda --- /dev/null +++ b/netwerk/base/nsTransportUtils.h @@ -0,0 +1,25 @@ +/* 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/. */ + +#ifndef nsTransportUtils_h__ +#define nsTransportUtils_h__ + +#include "nsITransport.h" + +/** + * This function returns a proxy object for a transport event sink instance. + * The transport event sink will be called on the thread indicated by the + * given event target. Like events are automatically coalesced. This means + * that for example if the status value is the same from event to event, and + * the previous event has not yet been delivered, then only one event will + * be delivered. The progress reported will be that from the second event. + + * Coalescing events can help prevent a backlog of unprocessed transport + * events in the case that the target thread is overworked. + */ +nsresult net_NewTransportEventSinkProxy(nsITransportEventSink** aResult, + nsITransportEventSink* aSink, + nsIEventTarget* aTarget); + +#endif // nsTransportUtils_h__ diff --git a/netwerk/base/nsUDPSocket.cpp b/netwerk/base/nsUDPSocket.cpp new file mode 100644 index 0000000000..e9e3541d00 --- /dev/null +++ b/netwerk/base/nsUDPSocket.cpp @@ -0,0 +1,1455 @@ +/* vim:set ts=2 sw=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 "mozilla/Attributes.h" +#include "mozilla/EndianUtils.h" +#include "mozilla/dom/TypedArray.h" +#include "mozilla/HoldDropJSObjects.h" +#include "mozilla/Telemetry.h" + +#include "nsSocketTransport2.h" +#include "nsUDPSocket.h" +#include "nsProxyRelease.h" +#include "nsError.h" +#include "nsNetCID.h" +#include "nsNetUtil.h" +#include "nsIOService.h" +#include "prnetdb.h" +#include "prio.h" +#include "nsNetAddr.h" +#include "nsNetSegmentUtils.h" +#include "IOActivityMonitor.h" +#include "nsServiceManagerUtils.h" +#include "nsStreamUtils.h" +#include "prerror.h" +#include "nsThreadUtils.h" +#include "nsIDNSRecord.h" +#include "nsIDNSService.h" +#include "nsICancelable.h" +#include "nsWrapperCacheInlines.h" + +namespace mozilla { +namespace net { + +static const uint32_t UDP_PACKET_CHUNK_SIZE = 1400; + +//----------------------------------------------------------------------------- + +typedef void (nsUDPSocket::*nsUDPSocketFunc)(void); + +static nsresult PostEvent(nsUDPSocket* s, nsUDPSocketFunc func) { + if (!gSocketTransportService) return NS_ERROR_FAILURE; + + return gSocketTransportService->Dispatch( + NewRunnableMethod("net::PostEvent", s, func), NS_DISPATCH_NORMAL); +} + +static nsresult ResolveHost(const nsACString& host, + const OriginAttributes& aOriginAttributes, + nsIDNSListener* listener) { + nsresult rv; + + nsCOMPtr<nsIDNSService> dns = + do_GetService("@mozilla.org/network/dns-service;1", &rv); + if (NS_FAILED(rv)) { + return rv; + } + + nsCOMPtr<nsICancelable> tmpOutstanding; + return dns->AsyncResolveNative(host, nsIDNSService::RESOLVE_TYPE_DEFAULT, 0, + nullptr, listener, nullptr, aOriginAttributes, + getter_AddRefs(tmpOutstanding)); +} + +static nsresult CheckIOStatus(const NetAddr* aAddr) { + MOZ_ASSERT(gIOService); + + if (gIOService->IsNetTearingDown()) { + return NS_ERROR_FAILURE; + } + + if (gIOService->IsOffline() && !aAddr->IsLoopbackAddr()) { + return NS_ERROR_OFFLINE; + } + + return NS_OK; +} + +//----------------------------------------------------------------------------- + +class SetSocketOptionRunnable : public Runnable { + public: + SetSocketOptionRunnable(nsUDPSocket* aSocket, const PRSocketOptionData& aOpt) + : Runnable("net::SetSocketOptionRunnable"), + mSocket(aSocket), + mOpt(aOpt) {} + + NS_IMETHOD Run() override { return mSocket->SetSocketOption(mOpt); } + + private: + RefPtr<nsUDPSocket> mSocket; + PRSocketOptionData mOpt; +}; + +//----------------------------------------------------------------------------- +// nsUDPOutputStream impl +//----------------------------------------------------------------------------- +NS_IMPL_ISUPPORTS(nsUDPOutputStream, nsIOutputStream) + +nsUDPOutputStream::nsUDPOutputStream(nsUDPSocket* aSocket, PRFileDesc* aFD, + PRNetAddr& aPrClientAddr) + : mSocket(aSocket), + mFD(aFD), + mPrClientAddr(aPrClientAddr), + mIsClosed(false) {} + +NS_IMETHODIMP nsUDPOutputStream::Close() { + if (mIsClosed) return NS_BASE_STREAM_CLOSED; + + mIsClosed = true; + return NS_OK; +} + +NS_IMETHODIMP nsUDPOutputStream::Flush() { return NS_OK; } + +NS_IMETHODIMP nsUDPOutputStream::Write(const char* aBuf, uint32_t aCount, + uint32_t* _retval) { + if (mIsClosed) return NS_BASE_STREAM_CLOSED; + + *_retval = 0; + int32_t count = + PR_SendTo(mFD, aBuf, aCount, 0, &mPrClientAddr, PR_INTERVAL_NO_WAIT); + if (count < 0) { + PRErrorCode code = PR_GetError(); + return ErrorAccordingToNSPR(code); + } + + *_retval = count; + + mSocket->AddOutputBytes(count); + + return NS_OK; +} + +NS_IMETHODIMP nsUDPOutputStream::WriteFrom(nsIInputStream* aFromStream, + uint32_t aCount, uint32_t* _retval) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP nsUDPOutputStream::WriteSegments(nsReadSegmentFun aReader, + void* aClosure, uint32_t aCount, + uint32_t* _retval) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP nsUDPOutputStream::IsNonBlocking(bool* _retval) { + *_retval = true; + return NS_OK; +} + +//----------------------------------------------------------------------------- +// nsUDPMessage impl +//----------------------------------------------------------------------------- +NS_IMPL_CYCLE_COLLECTING_ADDREF(nsUDPMessage) +NS_IMPL_CYCLE_COLLECTING_RELEASE(nsUDPMessage) + +NS_IMPL_CYCLE_COLLECTION_CLASS(nsUDPMessage) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsUDPMessage) + NS_INTERFACE_MAP_ENTRY(nsISupports) + NS_INTERFACE_MAP_ENTRY(nsIUDPMessage) +NS_INTERFACE_MAP_END + +NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(nsUDPMessage) + NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mJsobj) +NS_IMPL_CYCLE_COLLECTION_TRACE_END + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsUDPMessage) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsUDPMessage) + tmp->mJsobj = nullptr; +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +nsUDPMessage::nsUDPMessage(NetAddr* aAddr, nsIOutputStream* aOutputStream, + FallibleTArray<uint8_t>&& aData) + : mOutputStream(aOutputStream), mData(std::move(aData)) { + memcpy(&mAddr, aAddr, sizeof(NetAddr)); +} + +nsUDPMessage::~nsUDPMessage() { DropJSObjects(this); } + +NS_IMETHODIMP +nsUDPMessage::GetFromAddr(nsINetAddr** aFromAddr) { + NS_ENSURE_ARG_POINTER(aFromAddr); + + nsCOMPtr<nsINetAddr> result = new nsNetAddr(&mAddr); + result.forget(aFromAddr); + + return NS_OK; +} + +NS_IMETHODIMP +nsUDPMessage::GetData(nsACString& aData) { + aData.Assign(reinterpret_cast<const char*>(mData.Elements()), mData.Length()); + return NS_OK; +} + +NS_IMETHODIMP +nsUDPMessage::GetOutputStream(nsIOutputStream** aOutputStream) { + NS_ENSURE_ARG_POINTER(aOutputStream); + NS_IF_ADDREF(*aOutputStream = mOutputStream); + return NS_OK; +} + +NS_IMETHODIMP +nsUDPMessage::GetRawData(JSContext* cx, JS::MutableHandleValue aRawData) { + if (!mJsobj) { + mJsobj = + dom::Uint8Array::Create(cx, nullptr, mData.Length(), mData.Elements()); + HoldJSObjects(this); + } + aRawData.setObject(*mJsobj); + return NS_OK; +} + +FallibleTArray<uint8_t>& nsUDPMessage::GetDataAsTArray() { return mData; } + +//----------------------------------------------------------------------------- +// nsUDPSocket +//----------------------------------------------------------------------------- + +nsUDPSocket::nsUDPSocket() + : mLock("nsUDPSocket.mLock"), + mFD(nullptr), + mOriginAttributes(), + mAttached(false), + mByteReadCount(0), + mByteWriteCount(0) { + this->mAddr.inet = {}; + mAddr.raw.family = PR_AF_UNSPEC; + // we want to be able to access the STS directly, and it may not have been + // constructed yet. the STS constructor sets gSocketTransportService. + if (!gSocketTransportService) { + // This call can fail if we're offline, for example. + nsCOMPtr<nsISocketTransportService> sts = + do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID); + } + + mSts = gSocketTransportService; +} + +nsUDPSocket::~nsUDPSocket() { CloseSocket(); } + +void nsUDPSocket::AddOutputBytes(uint64_t aBytes) { mByteWriteCount += aBytes; } + +void nsUDPSocket::OnMsgClose() { + UDPSOCKET_LOG(("nsUDPSocket::OnMsgClose [this=%p]\n", this)); + + if (NS_FAILED(mCondition)) return; + + // tear down socket. this signals the STS to detach our socket handler. + mCondition = NS_BINDING_ABORTED; + + // if we are attached, then socket transport service will call our + // OnSocketDetached method automatically. Otherwise, we have to call it + // (and thus close the socket) manually. + if (!mAttached) OnSocketDetached(mFD); +} + +void nsUDPSocket::OnMsgAttach() { + UDPSOCKET_LOG(("nsUDPSocket::OnMsgAttach [this=%p]\n", this)); + + if (NS_FAILED(mCondition)) return; + + mCondition = TryAttach(); + + // if we hit an error while trying to attach then bail... + if (NS_FAILED(mCondition)) { + UDPSOCKET_LOG(("nsUDPSocket::OnMsgAttach: TryAttach FAILED err=0x%" PRIx32 + " [this=%p]\n", + static_cast<uint32_t>(mCondition), this)); + NS_ASSERTION(!mAttached, "should not be attached already"); + OnSocketDetached(mFD); + } +} + +nsresult nsUDPSocket::TryAttach() { + nsresult rv; + + if (!gSocketTransportService) return NS_ERROR_FAILURE; + + rv = CheckIOStatus(&mAddr); + if (NS_FAILED(rv)) { + return rv; + } + + // + // find out if it is going to be ok to attach another socket to the STS. + // if not then we have to wait for the STS to tell us that it is ok. + // the notification is asynchronous, which means that when we could be + // in a race to call AttachSocket once notified. for this reason, when + // we get notified, we just re-enter this function. as a result, we are + // sure to ask again before calling AttachSocket. in this way we deal + // with the race condition. though it isn't the most elegant solution, + // it is far simpler than trying to build a system that would guarantee + // FIFO ordering (which wouldn't even be that valuable IMO). see bug + // 194402 for more info. + // + if (!gSocketTransportService->CanAttachSocket()) { + nsCOMPtr<nsIRunnable> event = NewRunnableMethod( + "net::nsUDPSocket::OnMsgAttach", this, &nsUDPSocket::OnMsgAttach); + + nsresult rv = gSocketTransportService->NotifyWhenCanAttachSocket(event); + if (NS_FAILED(rv)) return rv; + } + + // + // ok, we can now attach our socket to the STS for polling + // + rv = gSocketTransportService->AttachSocket(mFD, this); + if (NS_FAILED(rv)) return rv; + + mAttached = true; + + // + // now, configure our poll flags for listening... + // + mPollFlags = (PR_POLL_READ | PR_POLL_EXCEPT); + return NS_OK; +} + +namespace { +//----------------------------------------------------------------------------- +// UDPMessageProxy +//----------------------------------------------------------------------------- +class UDPMessageProxy final : public nsIUDPMessage { + public: + UDPMessageProxy(NetAddr* aAddr, nsIOutputStream* aOutputStream, + FallibleTArray<uint8_t>&& aData) + : mOutputStream(aOutputStream), mData(std::move(aData)) { + memcpy(&mAddr, aAddr, sizeof(mAddr)); + } + + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIUDPMESSAGE + + private: + ~UDPMessageProxy() = default; + + NetAddr mAddr; + nsCOMPtr<nsIOutputStream> mOutputStream; + FallibleTArray<uint8_t> mData; +}; + +NS_IMPL_ISUPPORTS(UDPMessageProxy, nsIUDPMessage) + +NS_IMETHODIMP +UDPMessageProxy::GetFromAddr(nsINetAddr** aFromAddr) { + NS_ENSURE_ARG_POINTER(aFromAddr); + + nsCOMPtr<nsINetAddr> result = new nsNetAddr(&mAddr); + result.forget(aFromAddr); + + return NS_OK; +} + +NS_IMETHODIMP +UDPMessageProxy::GetData(nsACString& aData) { + aData.Assign(reinterpret_cast<const char*>(mData.Elements()), mData.Length()); + return NS_OK; +} + +FallibleTArray<uint8_t>& UDPMessageProxy::GetDataAsTArray() { return mData; } + +NS_IMETHODIMP +UDPMessageProxy::GetRawData(JSContext* cx, JS::MutableHandleValue aRawData) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +UDPMessageProxy::GetOutputStream(nsIOutputStream** aOutputStream) { + NS_ENSURE_ARG_POINTER(aOutputStream); + NS_IF_ADDREF(*aOutputStream = mOutputStream); + return NS_OK; +} + +} // anonymous namespace + +//----------------------------------------------------------------------------- +// nsUDPSocket::nsASocketHandler +//----------------------------------------------------------------------------- + +void nsUDPSocket::OnSocketReady(PRFileDesc* fd, int16_t outFlags) { + UDPSOCKET_LOG( + ("nsUDPSocket::OnSocketReady: flags=%d [this=%p]\n", outFlags, this)); + NS_ASSERTION(NS_SUCCEEDED(mCondition), "oops"); + NS_ASSERTION(mFD == fd, "wrong file descriptor"); + NS_ASSERTION(outFlags != -1, "unexpected timeout condition reached"); + + if (outFlags & (PR_POLL_HUP | PR_POLL_NVAL)) { + NS_WARNING("error polling on listening socket"); + mCondition = NS_ERROR_UNEXPECTED; + return; + } + + PRNetAddr prClientAddr; + int32_t count; + // Bug 1252755 - use 9216 bytes to allign with nICEr and transportlayer to + // support the maximum size of jumbo frames + char buff[9216]; + count = PR_RecvFrom(mFD, buff, sizeof(buff), 0, &prClientAddr, + PR_INTERVAL_NO_WAIT); + if (count < 0) { + UDPSOCKET_LOG( + ("nsUDPSocket::OnSocketReady: PR_RecvFrom failed [this=%p]\n", this)); + return; + } + mByteReadCount += count; + + FallibleTArray<uint8_t> data; + if (!data.AppendElements(buff, count, fallible)) { + UDPSOCKET_LOG(( + "nsUDPSocket::OnSocketReady: AppendElements FAILED [this=%p]\n", this)); + mCondition = NS_ERROR_UNEXPECTED; + return; + } + + nsCOMPtr<nsIAsyncInputStream> pipeIn; + nsCOMPtr<nsIAsyncOutputStream> pipeOut; + + uint32_t segsize = UDP_PACKET_CHUNK_SIZE; + uint32_t segcount = 0; + net_ResolveSegmentParams(segsize, segcount); + nsresult rv = NS_NewPipe2(getter_AddRefs(pipeIn), getter_AddRefs(pipeOut), + true, true, segsize, segcount); + + if (NS_FAILED(rv)) { + return; + } + + RefPtr<nsUDPOutputStream> os = new nsUDPOutputStream(this, mFD, prClientAddr); + rv = NS_AsyncCopy(pipeIn, os, mSts, NS_ASYNCCOPY_VIA_READSEGMENTS, + UDP_PACKET_CHUNK_SIZE); + + if (NS_FAILED(rv)) { + return; + } + + NetAddr netAddr(&prClientAddr); + nsCOMPtr<nsIUDPMessage> message = + new UDPMessageProxy(&netAddr, pipeOut, std::move(data)); + mListener->OnPacketReceived(this, message); +} + +void nsUDPSocket::OnSocketDetached(PRFileDesc* fd) { + UDPSOCKET_LOG(("nsUDPSocket::OnSocketDetached [this=%p]\n", this)); + // force a failure condition if none set; maybe the STS is shutting down :-/ + if (NS_SUCCEEDED(mCondition)) mCondition = NS_ERROR_ABORT; + + if (mFD) { + NS_ASSERTION(mFD == fd, "wrong file descriptor"); + CloseSocket(); + } + + if (mListener) { + // need to atomically clear mListener. see our Close() method. + RefPtr<nsIUDPSocketListener> listener = nullptr; + { + MutexAutoLock lock(mLock); + listener = ToRefPtr(std::move(mListener)); + } + + if (listener) { + listener->OnStopListening(this, mCondition); + NS_ProxyRelease("nsUDPSocket::mListener", mListenerTarget, + listener.forget()); + } + } +} + +void nsUDPSocket::IsLocal(bool* aIsLocal) { + // If bound to loopback, this UDP socket only accepts local connections. + *aIsLocal = mAddr.IsLoopbackAddr(); +} + +//----------------------------------------------------------------------------- +// nsSocket::nsISupports +//----------------------------------------------------------------------------- + +NS_IMPL_ISUPPORTS(nsUDPSocket, nsIUDPSocket) + +//----------------------------------------------------------------------------- +// nsSocket::nsISocket +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +nsUDPSocket::Init(int32_t aPort, bool aLoopbackOnly, nsIPrincipal* aPrincipal, + bool aAddressReuse, uint8_t aOptionalArgc) { + NetAddr addr; + + if (aPort < 0) aPort = 0; + + addr.raw.family = AF_INET; + addr.inet.port = htons(aPort); + + if (aLoopbackOnly) + addr.inet.ip = htonl(INADDR_LOOPBACK); + else + addr.inet.ip = htonl(INADDR_ANY); + + return InitWithAddress(&addr, aPrincipal, aAddressReuse, aOptionalArgc); +} + +NS_IMETHODIMP +nsUDPSocket::Init2(const nsACString& aAddr, int32_t aPort, + nsIPrincipal* aPrincipal, bool aAddressReuse, + uint8_t aOptionalArgc) { + if (NS_WARN_IF(aAddr.IsEmpty())) { + return NS_ERROR_INVALID_ARG; + } + + PRNetAddr prAddr; + memset(&prAddr, 0, sizeof(prAddr)); + if (PR_StringToNetAddr(aAddr.BeginReading(), &prAddr) != PR_SUCCESS) { + return NS_ERROR_FAILURE; + } + + if (aPort < 0) { + aPort = 0; + } + + switch (prAddr.raw.family) { + case PR_AF_INET: + prAddr.inet.port = PR_htons(aPort); + break; + case PR_AF_INET6: + prAddr.ipv6.port = PR_htons(aPort); + break; + default: + MOZ_ASSERT_UNREACHABLE("Dont accept address other than IPv4 and IPv6"); + return NS_ERROR_ILLEGAL_VALUE; + } + + NetAddr addr; + PRNetAddrToNetAddr(&prAddr, &addr); + + return InitWithAddress(&addr, aPrincipal, aAddressReuse, aOptionalArgc); +} + +NS_IMETHODIMP +nsUDPSocket::InitWithAddress(const NetAddr* aAddr, nsIPrincipal* aPrincipal, + bool aAddressReuse, uint8_t aOptionalArgc) { + NS_ENSURE_TRUE(mFD == nullptr, NS_ERROR_ALREADY_INITIALIZED); + + nsresult rv; + + rv = CheckIOStatus(aAddr); + if (NS_FAILED(rv)) { + return rv; + } + + bool addressReuse = (aOptionalArgc == 1) ? aAddressReuse : true; + + if (aPrincipal) { + mOriginAttributes = aPrincipal->OriginAttributesRef(); + } + // + // configure listening socket... + // + + mFD = PR_OpenUDPSocket(aAddr->raw.family); + if (!mFD) { + NS_WARNING("unable to create UDP socket"); + return NS_ERROR_FAILURE; + } + + uint16_t port; + if (NS_FAILED(aAddr->GetPort(&port))) { + NS_WARNING("invalid bind address"); + goto fail; + } + + PRSocketOptionData opt; + + // Linux kernel will sometimes hand out a used port if we bind + // to port 0 with SO_REUSEADDR + if (port) { + opt.option = PR_SockOpt_Reuseaddr; + opt.value.reuse_addr = addressReuse; + PR_SetSocketOption(mFD, &opt); + } + + opt.option = PR_SockOpt_Nonblocking; + opt.value.non_blocking = true; + PR_SetSocketOption(mFD, &opt); + + PRNetAddr addr; + // Temporary work around for IPv6 until bug 1330490 is fixed + memset(&addr, 0, sizeof(addr)); + NetAddrToPRNetAddr(aAddr, &addr); + + if (PR_Bind(mFD, &addr) != PR_SUCCESS) { + NS_WARNING("failed to bind socket"); + goto fail; + } + + // get the resulting socket address, which may be different than what + // we passed to bind. + if (PR_GetSockName(mFD, &addr) != PR_SUCCESS) { + NS_WARNING("cannot get socket name"); + goto fail; + } + + PRNetAddrToNetAddr(&addr, &mAddr); + + // create proxy via IOActivityMonitor + IOActivityMonitor::MonitorSocket(mFD); + + // wait until AsyncListen is called before polling the socket for + // client connections. + return NS_OK; + +fail: + Close(); + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP +nsUDPSocket::Connect(const NetAddr* aAddr) { + UDPSOCKET_LOG(("nsUDPSocket::Connect [this=%p]\n", this)); + + NS_ENSURE_ARG(aAddr); + + if (NS_WARN_IF(!mFD)) { + return NS_ERROR_NOT_INITIALIZED; + } + + nsresult rv; + + rv = CheckIOStatus(aAddr); + if (NS_FAILED(rv)) { + return rv; + } + + bool onSTSThread = false; + mSts->IsOnCurrentThread(&onSTSThread); + NS_ASSERTION(onSTSThread, "NOT ON STS THREAD"); + if (!onSTSThread) { + return NS_ERROR_FAILURE; + } + + PRNetAddr prAddr; + memset(&prAddr, 0, sizeof(prAddr)); + NetAddrToPRNetAddr(aAddr, &prAddr); + + if (PR_Connect(mFD, &prAddr, PR_INTERVAL_NO_WAIT) != PR_SUCCESS) { + NS_WARNING("Cannot PR_Connect"); + return NS_ERROR_FAILURE; + } + PR_SetFDInheritable(mFD, false); + + // get the resulting socket address, which may have been updated. + PRNetAddr addr; + if (PR_GetSockName(mFD, &addr) != PR_SUCCESS) { + NS_WARNING("cannot get socket name"); + return NS_ERROR_FAILURE; + } + + PRNetAddrToNetAddr(&addr, &mAddr); + + return NS_OK; +} + +NS_IMETHODIMP +nsUDPSocket::Close() { + { + MutexAutoLock lock(mLock); + // we want to proxy the close operation to the socket thread if a listener + // has been set. otherwise, we should just close the socket here... + if (!mListener) { + // Here we want to go directly with closing the socket since some tests + // expects this happen synchronously. + CloseSocket(); + + return NS_OK; + } + } + return PostEvent(this, &nsUDPSocket::OnMsgClose); +} + +NS_IMETHODIMP +nsUDPSocket::GetPort(int32_t* aResult) { + // no need to enter the lock here + uint16_t result; + nsresult rv = mAddr.GetPort(&result); + *aResult = static_cast<int32_t>(result); + return rv; +} + +NS_IMETHODIMP +nsUDPSocket::GetLocalAddr(nsINetAddr** aResult) { + NS_ENSURE_ARG_POINTER(aResult); + + nsCOMPtr<nsINetAddr> result = new nsNetAddr(&mAddr); + result.forget(aResult); + + return NS_OK; +} + +void nsUDPSocket::CloseSocket() { + if (mFD) { + if (gIOService->IsNetTearingDown() && + ((PR_IntervalNow() - gIOService->NetTearingDownStarted()) > + gSocketTransportService->MaxTimeForPrClosePref())) { + // If shutdown last to long, let the socket leak and do not close it. + UDPSOCKET_LOG(("Intentional leak")); + } else { + PRIntervalTime closeStarted = 0; + if (gSocketTransportService->IsTelemetryEnabledAndNotSleepPhase()) { + closeStarted = PR_IntervalNow(); + } + + PR_Close(mFD); + + if (gSocketTransportService->IsTelemetryEnabledAndNotSleepPhase()) { + PRIntervalTime now = PR_IntervalNow(); + if (gIOService->IsNetTearingDown()) { + Telemetry::Accumulate(Telemetry::PRCLOSE_UDP_BLOCKING_TIME_SHUTDOWN, + PR_IntervalToMilliseconds(now - closeStarted)); + + } else if (PR_IntervalToSeconds( + now - gIOService->LastConnectivityChange()) < 60) { + Telemetry::Accumulate( + Telemetry::PRCLOSE_UDP_BLOCKING_TIME_CONNECTIVITY_CHANGE, + PR_IntervalToMilliseconds(now - closeStarted)); + + } else if (PR_IntervalToSeconds( + now - gIOService->LastNetworkLinkChange()) < 60) { + Telemetry::Accumulate( + Telemetry::PRCLOSE_UDP_BLOCKING_TIME_LINK_CHANGE, + PR_IntervalToMilliseconds(now - closeStarted)); + + } else if (PR_IntervalToSeconds( + now - gIOService->LastOfflineStateChange()) < 60) { + Telemetry::Accumulate(Telemetry::PRCLOSE_UDP_BLOCKING_TIME_OFFLINE, + PR_IntervalToMilliseconds(now - closeStarted)); + + } else { + Telemetry::Accumulate(Telemetry::PRCLOSE_UDP_BLOCKING_TIME_NORMAL, + PR_IntervalToMilliseconds(now - closeStarted)); + } + } + } + mFD = nullptr; + } +} + +NS_IMETHODIMP +nsUDPSocket::GetAddress(NetAddr* aResult) { + // no need to enter the lock here + memcpy(aResult, &mAddr, sizeof(mAddr)); + return NS_OK; +} + +namespace { +//----------------------------------------------------------------------------- +// SocketListenerProxy +//----------------------------------------------------------------------------- +class SocketListenerProxy final : public nsIUDPSocketListener { + ~SocketListenerProxy() = default; + + public: + explicit SocketListenerProxy(nsIUDPSocketListener* aListener) + : mListener(new nsMainThreadPtrHolder<nsIUDPSocketListener>( + "SocketListenerProxy::mListener", aListener)), + mTarget(GetCurrentEventTarget()) {} + + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIUDPSOCKETLISTENER + + class OnPacketReceivedRunnable : public Runnable { + public: + OnPacketReceivedRunnable( + const nsMainThreadPtrHandle<nsIUDPSocketListener>& aListener, + nsIUDPSocket* aSocket, nsIUDPMessage* aMessage) + : Runnable("net::SocketListenerProxy::OnPacketReceivedRunnable"), + mListener(aListener), + mSocket(aSocket), + mMessage(aMessage) {} + + NS_DECL_NSIRUNNABLE + + private: + nsMainThreadPtrHandle<nsIUDPSocketListener> mListener; + nsCOMPtr<nsIUDPSocket> mSocket; + nsCOMPtr<nsIUDPMessage> mMessage; + }; + + class OnStopListeningRunnable : public Runnable { + public: + OnStopListeningRunnable( + const nsMainThreadPtrHandle<nsIUDPSocketListener>& aListener, + nsIUDPSocket* aSocket, nsresult aStatus) + : Runnable("net::SocketListenerProxy::OnStopListeningRunnable"), + mListener(aListener), + mSocket(aSocket), + mStatus(aStatus) {} + + NS_DECL_NSIRUNNABLE + + private: + nsMainThreadPtrHandle<nsIUDPSocketListener> mListener; + nsCOMPtr<nsIUDPSocket> mSocket; + nsresult mStatus; + }; + + private: + nsMainThreadPtrHandle<nsIUDPSocketListener> mListener; + nsCOMPtr<nsIEventTarget> mTarget; +}; + +NS_IMPL_ISUPPORTS(SocketListenerProxy, nsIUDPSocketListener) + +NS_IMETHODIMP +SocketListenerProxy::OnPacketReceived(nsIUDPSocket* aSocket, + nsIUDPMessage* aMessage) { + RefPtr<OnPacketReceivedRunnable> r = + new OnPacketReceivedRunnable(mListener, aSocket, aMessage); + return mTarget->Dispatch(r, NS_DISPATCH_NORMAL); +} + +NS_IMETHODIMP +SocketListenerProxy::OnStopListening(nsIUDPSocket* aSocket, nsresult aStatus) { + RefPtr<OnStopListeningRunnable> r = + new OnStopListeningRunnable(mListener, aSocket, aStatus); + return mTarget->Dispatch(r, NS_DISPATCH_NORMAL); +} + +NS_IMETHODIMP +SocketListenerProxy::OnPacketReceivedRunnable::Run() { + NetAddr netAddr; + nsCOMPtr<nsINetAddr> nsAddr; + mMessage->GetFromAddr(getter_AddRefs(nsAddr)); + nsAddr->GetNetAddr(&netAddr); + + nsCOMPtr<nsIOutputStream> outputStream; + mMessage->GetOutputStream(getter_AddRefs(outputStream)); + + FallibleTArray<uint8_t>& data = mMessage->GetDataAsTArray(); + + nsCOMPtr<nsIUDPMessage> message = + new nsUDPMessage(&netAddr, outputStream, std::move(data)); + mListener->OnPacketReceived(mSocket, message); + return NS_OK; +} + +NS_IMETHODIMP +SocketListenerProxy::OnStopListeningRunnable::Run() { + mListener->OnStopListening(mSocket, mStatus); + return NS_OK; +} + +class SocketListenerProxyBackground final : public nsIUDPSocketListener { + ~SocketListenerProxyBackground() = default; + + public: + explicit SocketListenerProxyBackground(nsIUDPSocketListener* aListener) + : mListener(aListener), mTarget(GetCurrentEventTarget()) {} + + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIUDPSOCKETLISTENER + + class OnPacketReceivedRunnable : public Runnable { + public: + OnPacketReceivedRunnable(const nsCOMPtr<nsIUDPSocketListener>& aListener, + nsIUDPSocket* aSocket, nsIUDPMessage* aMessage) + : Runnable( + "net::SocketListenerProxyBackground::OnPacketReceivedRunnable"), + mListener(aListener), + mSocket(aSocket), + mMessage(aMessage) {} + + NS_DECL_NSIRUNNABLE + + private: + nsCOMPtr<nsIUDPSocketListener> mListener; + nsCOMPtr<nsIUDPSocket> mSocket; + nsCOMPtr<nsIUDPMessage> mMessage; + }; + + class OnStopListeningRunnable : public Runnable { + public: + OnStopListeningRunnable(const nsCOMPtr<nsIUDPSocketListener>& aListener, + nsIUDPSocket* aSocket, nsresult aStatus) + : Runnable( + "net::SocketListenerProxyBackground::OnStopListeningRunnable"), + mListener(aListener), + mSocket(aSocket), + mStatus(aStatus) {} + + NS_DECL_NSIRUNNABLE + + private: + nsCOMPtr<nsIUDPSocketListener> mListener; + nsCOMPtr<nsIUDPSocket> mSocket; + nsresult mStatus; + }; + + private: + nsCOMPtr<nsIUDPSocketListener> mListener; + nsCOMPtr<nsIEventTarget> mTarget; +}; + +NS_IMPL_ISUPPORTS(SocketListenerProxyBackground, nsIUDPSocketListener) + +NS_IMETHODIMP +SocketListenerProxyBackground::OnPacketReceived(nsIUDPSocket* aSocket, + nsIUDPMessage* aMessage) { + RefPtr<OnPacketReceivedRunnable> r = + new OnPacketReceivedRunnable(mListener, aSocket, aMessage); + return mTarget->Dispatch(r, NS_DISPATCH_NORMAL); +} + +NS_IMETHODIMP +SocketListenerProxyBackground::OnStopListening(nsIUDPSocket* aSocket, + nsresult aStatus) { + RefPtr<OnStopListeningRunnable> r = + new OnStopListeningRunnable(mListener, aSocket, aStatus); + return mTarget->Dispatch(r, NS_DISPATCH_NORMAL); +} + +NS_IMETHODIMP +SocketListenerProxyBackground::OnPacketReceivedRunnable::Run() { + NetAddr netAddr; + nsCOMPtr<nsINetAddr> nsAddr; + mMessage->GetFromAddr(getter_AddRefs(nsAddr)); + nsAddr->GetNetAddr(&netAddr); + + nsCOMPtr<nsIOutputStream> outputStream; + mMessage->GetOutputStream(getter_AddRefs(outputStream)); + + FallibleTArray<uint8_t>& data = mMessage->GetDataAsTArray(); + + UDPSOCKET_LOG(("%s [this=%p], len %zu", __FUNCTION__, this, data.Length())); + nsCOMPtr<nsIUDPMessage> message = + new UDPMessageProxy(&netAddr, outputStream, std::move(data)); + mListener->OnPacketReceived(mSocket, message); + return NS_OK; +} + +NS_IMETHODIMP +SocketListenerProxyBackground::OnStopListeningRunnable::Run() { + mListener->OnStopListening(mSocket, mStatus); + return NS_OK; +} + +class PendingSend : public nsIDNSListener { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIDNSLISTENER + + PendingSend(nsUDPSocket* aSocket, uint16_t aPort, + FallibleTArray<uint8_t>&& aData) + : mSocket(aSocket), mPort(aPort), mData(std::move(aData)) {} + + private: + virtual ~PendingSend() = default; + + RefPtr<nsUDPSocket> mSocket; + uint16_t mPort; + FallibleTArray<uint8_t> mData; +}; + +NS_IMPL_ISUPPORTS(PendingSend, nsIDNSListener) + +NS_IMETHODIMP +PendingSend::OnLookupComplete(nsICancelable* request, nsIDNSRecord* aRecord, + nsresult status) { + if (NS_FAILED(status)) { + NS_WARNING("Failed to send UDP packet due to DNS lookup failure"); + return NS_OK; + } + + nsCOMPtr<nsIDNSAddrRecord> rec = do_QueryInterface(aRecord); + MOZ_ASSERT(rec); + NetAddr addr; + if (NS_SUCCEEDED(rec->GetNextAddr(mPort, &addr))) { + uint32_t count; + nsresult rv = mSocket->SendWithAddress(&addr, mData, &count); + NS_ENSURE_SUCCESS(rv, rv); + } + + return NS_OK; +} + +class PendingSendStream : public nsIDNSListener { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIDNSLISTENER + + PendingSendStream(nsUDPSocket* aSocket, uint16_t aPort, + nsIInputStream* aStream) + : mSocket(aSocket), mPort(aPort), mStream(aStream) {} + + private: + virtual ~PendingSendStream() = default; + + RefPtr<nsUDPSocket> mSocket; + uint16_t mPort; + nsCOMPtr<nsIInputStream> mStream; +}; + +NS_IMPL_ISUPPORTS(PendingSendStream, nsIDNSListener) + +NS_IMETHODIMP +PendingSendStream::OnLookupComplete(nsICancelable* request, + nsIDNSRecord* aRecord, nsresult status) { + if (NS_FAILED(status)) { + NS_WARNING("Failed to send UDP packet due to DNS lookup failure"); + return NS_OK; + } + + nsCOMPtr<nsIDNSAddrRecord> rec = do_QueryInterface(aRecord); + MOZ_ASSERT(rec); + NetAddr addr; + if (NS_SUCCEEDED(rec->GetNextAddr(mPort, &addr))) { + nsresult rv = mSocket->SendBinaryStreamWithAddress(&addr, mStream); + NS_ENSURE_SUCCESS(rv, rv); + } + + return NS_OK; +} + +class SendRequestRunnable : public Runnable { + public: + SendRequestRunnable(nsUDPSocket* aSocket, const NetAddr& aAddr, + FallibleTArray<uint8_t>&& aData) + : Runnable("net::SendRequestRunnable"), + mSocket(aSocket), + mAddr(aAddr), + mData(std::move(aData)) {} + + NS_DECL_NSIRUNNABLE + + private: + RefPtr<nsUDPSocket> mSocket; + const NetAddr mAddr; + FallibleTArray<uint8_t> mData; +}; + +NS_IMETHODIMP +SendRequestRunnable::Run() { + uint32_t count; + mSocket->SendWithAddress(&mAddr, mData, &count); + return NS_OK; +} + +} // namespace + +NS_IMETHODIMP +nsUDPSocket::AsyncListen(nsIUDPSocketListener* aListener) { + // ensuring mFD implies ensuring mLock + NS_ENSURE_TRUE(mFD, NS_ERROR_NOT_INITIALIZED); + NS_ENSURE_TRUE(mListener == nullptr, NS_ERROR_IN_PROGRESS); + { + MutexAutoLock lock(mLock); + mListenerTarget = GetCurrentEventTarget(); + if (NS_IsMainThread()) { + // PNecko usage + mListener = new SocketListenerProxy(aListener); + } else { + // PBackground usage from dom/media/webrtc/transport + mListener = new SocketListenerProxyBackground(aListener); + } + } + return PostEvent(this, &nsUDPSocket::OnMsgAttach); +} + +NS_IMETHODIMP +nsUDPSocket::Send(const nsACString& aHost, uint16_t aPort, + const nsTArray<uint8_t>& aData, uint32_t* _retval) { + NS_ENSURE_ARG_POINTER(_retval); + + *_retval = 0; + + FallibleTArray<uint8_t> fallibleArray; + if (!fallibleArray.InsertElementsAt(0, aData, fallible)) { + return NS_ERROR_OUT_OF_MEMORY; + } + + nsCOMPtr<nsIDNSListener> listener = + new PendingSend(this, aPort, std::move(fallibleArray)); + + nsresult rv = ResolveHost(aHost, mOriginAttributes, listener); + NS_ENSURE_SUCCESS(rv, rv); + + *_retval = aData.Length(); + return NS_OK; +} + +NS_IMETHODIMP +nsUDPSocket::SendWithAddr(nsINetAddr* aAddr, const nsTArray<uint8_t>& aData, + uint32_t* _retval) { + NS_ENSURE_ARG(aAddr); + NS_ENSURE_ARG_POINTER(_retval); + + NetAddr netAddr; + aAddr->GetNetAddr(&netAddr); + return SendWithAddress(&netAddr, aData, _retval); +} + +NS_IMETHODIMP +nsUDPSocket::SendWithAddress(const NetAddr* aAddr, + const nsTArray<uint8_t>& aData, + uint32_t* _retval) { + NS_ENSURE_ARG(aAddr); + NS_ENSURE_ARG_POINTER(_retval); + + *_retval = 0; + + PRNetAddr prAddr; + NetAddrToPRNetAddr(aAddr, &prAddr); + + bool onSTSThread = false; + mSts->IsOnCurrentThread(&onSTSThread); + + if (onSTSThread) { + MutexAutoLock lock(mLock); + if (!mFD) { + // socket is not initialized or has been closed + return NS_ERROR_FAILURE; + } + int32_t count = + PR_SendTo(mFD, aData.Elements(), sizeof(uint8_t) * aData.Length(), 0, + &prAddr, PR_INTERVAL_NO_WAIT); + if (count < 0) { + PRErrorCode code = PR_GetError(); + return ErrorAccordingToNSPR(code); + } + this->AddOutputBytes(count); + *_retval = count; + } else { + FallibleTArray<uint8_t> fallibleArray; + if (!fallibleArray.InsertElementsAt(0, aData, fallible)) { + return NS_ERROR_OUT_OF_MEMORY; + } + + nsresult rv = mSts->Dispatch( + new SendRequestRunnable(this, *aAddr, std::move(fallibleArray)), + NS_DISPATCH_NORMAL); + NS_ENSURE_SUCCESS(rv, rv); + *_retval = aData.Length(); + } + return NS_OK; +} + +NS_IMETHODIMP +nsUDPSocket::SendBinaryStream(const nsACString& aHost, uint16_t aPort, + nsIInputStream* aStream) { + NS_ENSURE_ARG(aStream); + + nsCOMPtr<nsIDNSListener> listener = + new PendingSendStream(this, aPort, aStream); + + return ResolveHost(aHost, mOriginAttributes, listener); +} + +NS_IMETHODIMP +nsUDPSocket::SendBinaryStreamWithAddress(const NetAddr* aAddr, + nsIInputStream* aStream) { + NS_ENSURE_ARG(aAddr); + NS_ENSURE_ARG(aStream); + + PRNetAddr prAddr; + PR_InitializeNetAddr(PR_IpAddrAny, 0, &prAddr); + NetAddrToPRNetAddr(aAddr, &prAddr); + + RefPtr<nsUDPOutputStream> os = new nsUDPOutputStream(this, mFD, prAddr); + return NS_AsyncCopy(aStream, os, mSts, NS_ASYNCCOPY_VIA_READSEGMENTS, + UDP_PACKET_CHUNK_SIZE); +} + +nsresult nsUDPSocket::SetSocketOption(const PRSocketOptionData& aOpt) { + bool onSTSThread = false; + mSts->IsOnCurrentThread(&onSTSThread); + + if (!onSTSThread) { + // Dispatch to STS thread and re-enter this method there + nsCOMPtr<nsIRunnable> runnable = new SetSocketOptionRunnable(this, aOpt); + nsresult rv = mSts->Dispatch(runnable, NS_DISPATCH_NORMAL); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + return NS_OK; + } + + if (NS_WARN_IF(!mFD)) { + return NS_ERROR_NOT_INITIALIZED; + } + + if (PR_SetSocketOption(mFD, &aOpt) != PR_SUCCESS) { + UDPSOCKET_LOG( + ("nsUDPSocket::SetSocketOption [this=%p] failed for type %d, " + "error %d\n", + this, aOpt.option, PR_GetError())); + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +NS_IMETHODIMP +nsUDPSocket::JoinMulticast(const nsACString& aAddr, const nsACString& aIface) { + if (NS_WARN_IF(aAddr.IsEmpty())) { + return NS_ERROR_INVALID_ARG; + } + if (NS_WARN_IF(!mFD)) { + return NS_ERROR_NOT_INITIALIZED; + } + + PRNetAddr prAddr; + if (PR_StringToNetAddr(aAddr.BeginReading(), &prAddr) != PR_SUCCESS) { + return NS_ERROR_FAILURE; + } + + PRNetAddr prIface; + if (aIface.IsEmpty()) { + PR_InitializeNetAddr(PR_IpAddrAny, 0, &prIface); + } else { + if (PR_StringToNetAddr(aIface.BeginReading(), &prIface) != PR_SUCCESS) { + return NS_ERROR_FAILURE; + } + } + + return JoinMulticastInternal(prAddr, prIface); +} + +NS_IMETHODIMP +nsUDPSocket::JoinMulticastAddr(const NetAddr aAddr, const NetAddr* aIface) { + if (NS_WARN_IF(!mFD)) { + return NS_ERROR_NOT_INITIALIZED; + } + + PRNetAddr prAddr; + NetAddrToPRNetAddr(&aAddr, &prAddr); + + PRNetAddr prIface; + if (!aIface) { + PR_InitializeNetAddr(PR_IpAddrAny, 0, &prIface); + } else { + NetAddrToPRNetAddr(aIface, &prIface); + } + + return JoinMulticastInternal(prAddr, prIface); +} + +nsresult nsUDPSocket::JoinMulticastInternal(const PRNetAddr& aAddr, + const PRNetAddr& aIface) { + PRSocketOptionData opt; + + opt.option = PR_SockOpt_AddMember; + opt.value.add_member.mcaddr = aAddr; + opt.value.add_member.ifaddr = aIface; + + nsresult rv = SetSocketOption(opt); + if (NS_WARN_IF(NS_FAILED(rv))) { + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +NS_IMETHODIMP +nsUDPSocket::LeaveMulticast(const nsACString& aAddr, const nsACString& aIface) { + if (NS_WARN_IF(aAddr.IsEmpty())) { + return NS_ERROR_INVALID_ARG; + } + if (NS_WARN_IF(!mFD)) { + return NS_ERROR_NOT_INITIALIZED; + } + + PRNetAddr prAddr; + if (PR_StringToNetAddr(aAddr.BeginReading(), &prAddr) != PR_SUCCESS) { + return NS_ERROR_FAILURE; + } + + PRNetAddr prIface; + if (aIface.IsEmpty()) { + PR_InitializeNetAddr(PR_IpAddrAny, 0, &prIface); + } else { + if (PR_StringToNetAddr(aIface.BeginReading(), &prIface) != PR_SUCCESS) { + return NS_ERROR_FAILURE; + } + } + + return LeaveMulticastInternal(prAddr, prIface); +} + +NS_IMETHODIMP +nsUDPSocket::LeaveMulticastAddr(const NetAddr aAddr, const NetAddr* aIface) { + if (NS_WARN_IF(!mFD)) { + return NS_ERROR_NOT_INITIALIZED; + } + + PRNetAddr prAddr; + NetAddrToPRNetAddr(&aAddr, &prAddr); + + PRNetAddr prIface; + if (!aIface) { + PR_InitializeNetAddr(PR_IpAddrAny, 0, &prIface); + } else { + NetAddrToPRNetAddr(aIface, &prIface); + } + + return LeaveMulticastInternal(prAddr, prIface); +} + +nsresult nsUDPSocket::LeaveMulticastInternal(const PRNetAddr& aAddr, + const PRNetAddr& aIface) { + PRSocketOptionData opt; + + opt.option = PR_SockOpt_DropMember; + opt.value.drop_member.mcaddr = aAddr; + opt.value.drop_member.ifaddr = aIface; + + nsresult rv = SetSocketOption(opt); + if (NS_WARN_IF(NS_FAILED(rv))) { + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +NS_IMETHODIMP +nsUDPSocket::GetMulticastLoopback(bool* aLoopback) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsUDPSocket::SetMulticastLoopback(bool aLoopback) { + if (NS_WARN_IF(!mFD)) { + return NS_ERROR_NOT_INITIALIZED; + } + + PRSocketOptionData opt; + + opt.option = PR_SockOpt_McastLoopback; + opt.value.mcast_loopback = aLoopback; + + nsresult rv = SetSocketOption(opt); + if (NS_WARN_IF(NS_FAILED(rv))) { + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +NS_IMETHODIMP +nsUDPSocket::GetRecvBufferSize(int* size) { + // Bug 1252759 - missing support for GetSocketOption + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsUDPSocket::SetRecvBufferSize(int size) { + if (NS_WARN_IF(!mFD)) { + return NS_ERROR_NOT_INITIALIZED; + } + + PRSocketOptionData opt; + + opt.option = PR_SockOpt_RecvBufferSize; + opt.value.recv_buffer_size = size; + + nsresult rv = SetSocketOption(opt); + if (NS_WARN_IF(NS_FAILED(rv))) { + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +NS_IMETHODIMP +nsUDPSocket::GetSendBufferSize(int* size) { + // Bug 1252759 - missing support for GetSocketOption + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsUDPSocket::SetSendBufferSize(int size) { + if (NS_WARN_IF(!mFD)) { + return NS_ERROR_NOT_INITIALIZED; + } + + PRSocketOptionData opt; + + opt.option = PR_SockOpt_SendBufferSize; + opt.value.send_buffer_size = size; + + nsresult rv = SetSocketOption(opt); + if (NS_WARN_IF(NS_FAILED(rv))) { + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +NS_IMETHODIMP +nsUDPSocket::GetMulticastInterface(nsACString& aIface) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsUDPSocket::GetMulticastInterfaceAddr(NetAddr* aIface) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsUDPSocket::SetMulticastInterface(const nsACString& aIface) { + if (NS_WARN_IF(!mFD)) { + return NS_ERROR_NOT_INITIALIZED; + } + + PRNetAddr prIface; + if (aIface.IsEmpty()) { + PR_InitializeNetAddr(PR_IpAddrAny, 0, &prIface); + } else { + if (PR_StringToNetAddr(aIface.BeginReading(), &prIface) != PR_SUCCESS) { + return NS_ERROR_FAILURE; + } + } + + return SetMulticastInterfaceInternal(prIface); +} + +NS_IMETHODIMP +nsUDPSocket::SetMulticastInterfaceAddr(NetAddr aIface) { + if (NS_WARN_IF(!mFD)) { + return NS_ERROR_NOT_INITIALIZED; + } + + PRNetAddr prIface; + NetAddrToPRNetAddr(&aIface, &prIface); + + return SetMulticastInterfaceInternal(prIface); +} + +nsresult nsUDPSocket::SetMulticastInterfaceInternal(const PRNetAddr& aIface) { + PRSocketOptionData opt; + + opt.option = PR_SockOpt_McastInterface; + opt.value.mcast_if = aIface; + + nsresult rv = SetSocketOption(opt); + if (NS_WARN_IF(NS_FAILED(rv))) { + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/base/nsUDPSocket.h b/netwerk/base/nsUDPSocket.h new file mode 100644 index 0000000000..77ca7e32f2 --- /dev/null +++ b/netwerk/base/nsUDPSocket.h @@ -0,0 +1,113 @@ +/* vim:set ts=2 sw=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/. */ + +#ifndef nsUDPSocket_h__ +#define nsUDPSocket_h__ + +#include "nsIUDPSocket.h" +#include "mozilla/Mutex.h" +#include "mozilla/net/DNS.h" +#include "nsIOutputStream.h" +#include "nsCycleCollectionParticipant.h" + +//----------------------------------------------------------------------------- + +namespace mozilla { +namespace net { + +class nsUDPSocket final : public nsASocketHandler, public nsIUDPSocket { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIUDPSOCKET + + // nsASocketHandler methods: + virtual void OnSocketReady(PRFileDesc* fd, int16_t outFlags) override; + virtual void OnSocketDetached(PRFileDesc* fd) override; + virtual void IsLocal(bool* aIsLocal) override; + + uint64_t ByteCountSent() override { return mByteWriteCount; } + uint64_t ByteCountReceived() override { return mByteReadCount; } + + void AddOutputBytes(uint64_t aBytes); + + nsUDPSocket(); + + private: + virtual ~nsUDPSocket(); + + void OnMsgClose(); + void OnMsgAttach(); + + // try attaching our socket (mFD) to the STS's poll list. + nsresult TryAttach(); + + friend class SetSocketOptionRunnable; + nsresult SetSocketOption(const PRSocketOptionData& aOpt); + nsresult JoinMulticastInternal(const PRNetAddr& aAddr, + const PRNetAddr& aIface); + nsresult LeaveMulticastInternal(const PRNetAddr& aAddr, + const PRNetAddr& aIface); + nsresult SetMulticastInterfaceInternal(const PRNetAddr& aIface); + + void CloseSocket(); + + // lock protects access to mListener; + // so mListener is not cleared while being used/locked. + Mutex mLock; + PRFileDesc* mFD; + NetAddr mAddr; + OriginAttributes mOriginAttributes; + nsCOMPtr<nsIUDPSocketListener> mListener; + nsCOMPtr<nsIEventTarget> mListenerTarget; + bool mAttached; + RefPtr<nsSocketTransportService> mSts; + + uint64_t mByteReadCount; + uint64_t mByteWriteCount; +}; + +//----------------------------------------------------------------------------- + +class nsUDPMessage : public nsIUDPMessage { + public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(nsUDPMessage) + NS_DECL_NSIUDPMESSAGE + + nsUDPMessage(NetAddr* aAddr, nsIOutputStream* aOutputStream, + FallibleTArray<uint8_t>&& aData); + + private: + virtual ~nsUDPMessage(); + + NetAddr mAddr; + nsCOMPtr<nsIOutputStream> mOutputStream; + FallibleTArray<uint8_t> mData; + JS::Heap<JSObject*> mJsobj; +}; + +//----------------------------------------------------------------------------- + +class nsUDPOutputStream : public nsIOutputStream { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIOUTPUTSTREAM + + nsUDPOutputStream(nsUDPSocket* aSocket, PRFileDesc* aFD, + PRNetAddr& aPrClientAddr); + + private: + virtual ~nsUDPOutputStream() = default; + + RefPtr<nsUDPSocket> mSocket; + PRFileDesc* mFD; + PRNetAddr mPrClientAddr; + bool mIsClosed; +}; + +} // namespace net +} // namespace mozilla + +#endif // nsUDPSocket_h__ diff --git a/netwerk/base/nsURIHashKey.h b/netwerk/base/nsURIHashKey.h new file mode 100644 index 0000000000..fb98ae0d21 --- /dev/null +++ b/netwerk/base/nsURIHashKey.h @@ -0,0 +1,71 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ +#ifndef nsURIHashKey_h__ +#define nsURIHashKey_h__ + +#include <utility> + +#include "PLDHashTable.h" +#include "mozilla/Unused.h" +#include "nsCOMPtr.h" +#include "nsHashKeys.h" +#include "nsIURI.h" + +/** + * Hashtable key class to use with nsTHashtable/nsBaseHashtable + */ +class nsURIHashKey : public PLDHashEntryHdr { + public: + typedef nsIURI* KeyType; + typedef const nsIURI* KeyTypePointer; + + nsURIHashKey() { MOZ_COUNT_CTOR(nsURIHashKey); } + explicit nsURIHashKey(const nsIURI* aKey) : mKey(const_cast<nsIURI*>(aKey)) { + MOZ_COUNT_CTOR(nsURIHashKey); + } + nsURIHashKey(nsURIHashKey&& toMove) + : PLDHashEntryHdr(std::move(toMove)), mKey(std::move(toMove.mKey)) { + MOZ_COUNT_CTOR(nsURIHashKey); + } + MOZ_COUNTED_DTOR(nsURIHashKey) + + nsURIHashKey& operator=(const nsURIHashKey& aOther) { + mKey = aOther.mKey; + return *this; + } + + nsIURI* GetKey() const { return mKey; } + + bool KeyEquals(const nsIURI* aKey) const { + bool eq; + if (!mKey) { + return !aKey; + } + if (NS_SUCCEEDED(mKey->Equals(const_cast<nsIURI*>(aKey), &eq))) { + return eq; + } + return false; + } + + static const nsIURI* KeyToPointer(nsIURI* aKey) { return aKey; } + static PLDHashNumber HashKey(const nsIURI* aKey) { + if (!aKey) { + // If the key is null, return hash for empty string. + return mozilla::HashString(""_ns); + } + nsAutoCString spec; + // If GetSpec() fails, ignoring the failure and proceeding with an + // empty |spec| seems like the best thing to do. + mozilla::Unused << const_cast<nsIURI*>(aKey)->GetSpec(spec); + return mozilla::HashString(spec); + } + + enum { ALLOW_MEMMOVE = true }; + + protected: + nsCOMPtr<nsIURI> mKey; +}; + +#endif // nsURIHashKey_h__ diff --git a/netwerk/base/nsURLHelper.cpp b/netwerk/base/nsURLHelper.cpp new file mode 100644 index 0000000000..2ddee86603 --- /dev/null +++ b/netwerk/base/nsURLHelper.cpp @@ -0,0 +1,1135 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=4 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 "nsURLHelper.h" + +#include "mozilla/Encoding.h" +#include "mozilla/RangedPtr.h" +#include "mozilla/TextUtils.h" + +#include <algorithm> +#include <iterator> + +#include "nsASCIIMask.h" +#include "nsIFile.h" +#include "nsIURLParser.h" +#include "nsCOMPtr.h" +#include "nsCRT.h" +#include "nsNetCID.h" +#include "mozilla/Preferences.h" +#include "prnetdb.h" +#include "mozilla/StaticPrefs_network.h" +#include "mozilla/Tokenizer.h" +#include "nsEscape.h" +#include "nsDOMString.h" +#include "mozilla/net/rust_helper.h" + +using namespace mozilla; + +//---------------------------------------------------------------------------- +// Init/Shutdown +//---------------------------------------------------------------------------- + +static bool gInitialized = false; +static nsIURLParser* gNoAuthURLParser = nullptr; +static nsIURLParser* gAuthURLParser = nullptr; +static nsIURLParser* gStdURLParser = nullptr; + +static void InitGlobals() { + nsCOMPtr<nsIURLParser> parser; + + parser = do_GetService(NS_NOAUTHURLPARSER_CONTRACTID); + NS_ASSERTION(parser, "failed getting 'noauth' url parser"); + if (parser) { + gNoAuthURLParser = parser.get(); + NS_ADDREF(gNoAuthURLParser); + } + + parser = do_GetService(NS_AUTHURLPARSER_CONTRACTID); + NS_ASSERTION(parser, "failed getting 'auth' url parser"); + if (parser) { + gAuthURLParser = parser.get(); + NS_ADDREF(gAuthURLParser); + } + + parser = do_GetService(NS_STDURLPARSER_CONTRACTID); + NS_ASSERTION(parser, "failed getting 'std' url parser"); + if (parser) { + gStdURLParser = parser.get(); + NS_ADDREF(gStdURLParser); + } + + gInitialized = true; +} + +void net_ShutdownURLHelper() { + if (gInitialized) { + NS_IF_RELEASE(gNoAuthURLParser); + NS_IF_RELEASE(gAuthURLParser); + NS_IF_RELEASE(gStdURLParser); + gInitialized = false; + } +} + +//---------------------------------------------------------------------------- +// nsIURLParser getters +//---------------------------------------------------------------------------- + +nsIURLParser* net_GetAuthURLParser() { + if (!gInitialized) InitGlobals(); + return gAuthURLParser; +} + +nsIURLParser* net_GetNoAuthURLParser() { + if (!gInitialized) InitGlobals(); + return gNoAuthURLParser; +} + +nsIURLParser* net_GetStdURLParser() { + if (!gInitialized) InitGlobals(); + return gStdURLParser; +} + +//--------------------------------------------------------------------------- +// GetFileFromURLSpec implementations +//--------------------------------------------------------------------------- +nsresult net_GetURLSpecFromDir(nsIFile* aFile, nsACString& result) { + nsAutoCString escPath; + nsresult rv = net_GetURLSpecFromActualFile(aFile, escPath); + if (NS_FAILED(rv)) return rv; + + if (escPath.Last() != '/') { + escPath += '/'; + } + + result = escPath; + return NS_OK; +} + +nsresult net_GetURLSpecFromFile(nsIFile* aFile, nsACString& result) { + nsAutoCString escPath; + nsresult rv = net_GetURLSpecFromActualFile(aFile, escPath); + if (NS_FAILED(rv)) return rv; + + // if this file references a directory, then we need to ensure that the + // URL ends with a slash. this is important since it affects the rules + // for relative URL resolution when this URL is used as a base URL. + // if the file does not exist, then we make no assumption about its type, + // and simply leave the URL unmodified. + if (escPath.Last() != '/') { + bool dir; + rv = aFile->IsDirectory(&dir); + if (NS_SUCCEEDED(rv) && dir) escPath += '/'; + } + + result = escPath; + return NS_OK; +} + +//---------------------------------------------------------------------------- +// file:// URL parsing +//---------------------------------------------------------------------------- + +nsresult net_ParseFileURL(const nsACString& inURL, nsACString& outDirectory, + nsACString& outFileBaseName, + nsACString& outFileExtension) { + nsresult rv; + + if (inURL.Length() > + (uint32_t)StaticPrefs::network_standard_url_max_length()) { + return NS_ERROR_MALFORMED_URI; + } + + outDirectory.Truncate(); + outFileBaseName.Truncate(); + outFileExtension.Truncate(); + + const nsPromiseFlatCString& flatURL = PromiseFlatCString(inURL); + const char* url = flatURL.get(); + + nsAutoCString scheme; + rv = net_ExtractURLScheme(flatURL, scheme); + if (NS_FAILED(rv)) return rv; + + if (!scheme.EqualsLiteral("file")) { + NS_ERROR("must be a file:// url"); + return NS_ERROR_UNEXPECTED; + } + + nsIURLParser* parser = net_GetNoAuthURLParser(); + NS_ENSURE_TRUE(parser, NS_ERROR_UNEXPECTED); + + uint32_t pathPos, filepathPos, directoryPos, basenamePos, extensionPos; + int32_t pathLen, filepathLen, directoryLen, basenameLen, extensionLen; + + // invoke the parser to extract the URL path + rv = parser->ParseURL(url, flatURL.Length(), nullptr, + nullptr, // don't care about scheme + nullptr, nullptr, // don't care about authority + &pathPos, &pathLen); + if (NS_FAILED(rv)) return rv; + + // invoke the parser to extract filepath from the path + rv = parser->ParsePath(url + pathPos, pathLen, &filepathPos, &filepathLen, + nullptr, nullptr, // don't care about query + nullptr, nullptr); // don't care about ref + if (NS_FAILED(rv)) return rv; + + filepathPos += pathPos; + + // invoke the parser to extract the directory and filename from filepath + rv = parser->ParseFilePath(url + filepathPos, filepathLen, &directoryPos, + &directoryLen, &basenamePos, &basenameLen, + &extensionPos, &extensionLen); + if (NS_FAILED(rv)) return rv; + + if (directoryLen > 0) + outDirectory = Substring(inURL, filepathPos + directoryPos, directoryLen); + if (basenameLen > 0) + outFileBaseName = Substring(inURL, filepathPos + basenamePos, basenameLen); + if (extensionLen > 0) + outFileExtension = + Substring(inURL, filepathPos + extensionPos, extensionLen); + // since we are using a no-auth url parser, there will never be a host + // XXX not strictly true... file://localhost/foo/bar.html is a valid URL + + return NS_OK; +} + +//---------------------------------------------------------------------------- +// path manipulation functions +//---------------------------------------------------------------------------- + +// Replace all /./ with a / while resolving URLs +// But only till #? +void net_CoalesceDirs(netCoalesceFlags flags, char* path) { + /* Stolen from the old netlib's mkparse.c. + * + * modifies a url of the form /foo/../foo1 -> /foo1 + * and /foo/./foo1 -> /foo/foo1 + * and /foo/foo1/.. -> /foo/ + */ + char* fwdPtr = path; + char* urlPtr = path; + char* lastslash = path; + uint32_t traversal = 0; + uint32_t special_ftp_len = 0; + + /* Remember if this url is a special ftp one: */ + if (flags & NET_COALESCE_DOUBLE_SLASH_IS_ROOT) { + /* some schemes (for example ftp) have the speciality that + the path can begin // or /%2F to mark the root of the + servers filesystem, a simple / only marks the root relative + to the user loging in. We remember the length of the marker */ + if (nsCRT::strncasecmp(path, "/%2F", 4) == 0) + special_ftp_len = 4; + else if (strncmp(path, "//", 2) == 0) + special_ftp_len = 2; + } + + /* find the last slash before # or ? */ + for (; (*fwdPtr != '\0') && (*fwdPtr != '?') && (*fwdPtr != '#'); ++fwdPtr) { + } + + /* found nothing, but go back one only */ + /* if there is something to go back to */ + if (fwdPtr != path && *fwdPtr == '\0') { + --fwdPtr; + } + + /* search the slash */ + for (; (fwdPtr != path) && (*fwdPtr != '/'); --fwdPtr) { + } + lastslash = fwdPtr; + fwdPtr = path; + + /* replace all %2E or %2e with . in the path */ + /* but stop at lastchar if non null */ + for (; (*fwdPtr != '\0') && (*fwdPtr != '?') && (*fwdPtr != '#') && + (*lastslash == '\0' || fwdPtr != lastslash); + ++fwdPtr) { + if (*fwdPtr == '%' && *(fwdPtr + 1) == '2' && + (*(fwdPtr + 2) == 'E' || *(fwdPtr + 2) == 'e')) { + *urlPtr++ = '.'; + ++fwdPtr; + ++fwdPtr; + } else { + *urlPtr++ = *fwdPtr; + } + } + // Copy remaining stuff past the #?; + for (; *fwdPtr != '\0'; ++fwdPtr) { + *urlPtr++ = *fwdPtr; + } + *urlPtr = '\0'; // terminate the url + + // start again, this time for real + fwdPtr = path; + urlPtr = path; + + for (; (*fwdPtr != '\0') && (*fwdPtr != '?') && (*fwdPtr != '#'); ++fwdPtr) { + if (*fwdPtr == '/' && *(fwdPtr + 1) == '.' && *(fwdPtr + 2) == '/') { + // remove . followed by slash + ++fwdPtr; + } else if (*fwdPtr == '/' && *(fwdPtr + 1) == '.' && *(fwdPtr + 2) == '.' && + (*(fwdPtr + 3) == '/' || + *(fwdPtr + 3) == '\0' || // This will take care of + *(fwdPtr + 3) == '?' || // something like foo/bar/..#sometag + *(fwdPtr + 3) == '#')) { + // remove foo/.. + // reverse the urlPtr to the previous slash if possible + // if url does not allow relative root then drop .. above root + // otherwise retain them in the path + if (traversal > 0 || !(flags & NET_COALESCE_ALLOW_RELATIVE_ROOT)) { + if (urlPtr != path) urlPtr--; // we must be going back at least by one + for (; *urlPtr != '/' && urlPtr != path; urlPtr--) + ; // null body + --traversal; // count back + // forward the fwdPtr past the ../ + fwdPtr += 2; + // if we have reached the beginning of the path + // while searching for the previous / and we remember + // that it is an url that begins with /%2F then + // advance urlPtr again by 3 chars because /%2F already + // marks the root of the path + if (urlPtr == path && special_ftp_len > 3) { + ++urlPtr; + ++urlPtr; + ++urlPtr; + } + // special case if we have reached the end + // to preserve the last / + if (*fwdPtr == '.' && *(fwdPtr + 1) == '\0') ++urlPtr; + } else { + // there are to much /.. in this path, just copy them instead. + // forward the urlPtr past the /.. and copying it + + // However if we remember it is an url that starts with + // /%2F and urlPtr just points at the "F" of "/%2F" then do + // not overwrite it with the /, just copy .. and move forward + // urlPtr. + if (special_ftp_len > 3 && urlPtr == path + special_ftp_len - 1) + ++urlPtr; + else + *urlPtr++ = *fwdPtr; + ++fwdPtr; + *urlPtr++ = *fwdPtr; + ++fwdPtr; + *urlPtr++ = *fwdPtr; + } + } else { + // count the hierachie, but only if we do not have reached + // the root of some special urls with a special root marker + if (*fwdPtr == '/' && *(fwdPtr + 1) != '.' && + (special_ftp_len != 2 || *(fwdPtr + 1) != '/')) + traversal++; + // copy the url incrementaly + *urlPtr++ = *fwdPtr; + } + } + + /* + * Now lets remove trailing . case + * /foo/foo1/. -> /foo/foo1/ + */ + + if ((urlPtr > (path + 1)) && (*(urlPtr - 1) == '.') && (*(urlPtr - 2) == '/')) + urlPtr--; + + // Copy remaining stuff past the #?; + for (; *fwdPtr != '\0'; ++fwdPtr) { + *urlPtr++ = *fwdPtr; + } + *urlPtr = '\0'; // terminate the url +} + +//---------------------------------------------------------------------------- +// scheme fu +//---------------------------------------------------------------------------- + +static bool net_IsValidSchemeChar(const char aChar) { + return mozilla::net::rust_net_is_valid_scheme_char(aChar); +} + +/* Extract URI-Scheme if possible */ +nsresult net_ExtractURLScheme(const nsACString& inURI, nsACString& scheme) { + nsACString::const_iterator start, end; + inURI.BeginReading(start); + inURI.EndReading(end); + + // Strip C0 and space from begining + while (start != end) { + if ((uint8_t)*start > 0x20) { + break; + } + start++; + } + + Tokenizer p(Substring(start, end), "\r\n\t"); + p.Record(); + if (!p.CheckChar(IsAsciiAlpha)) { + // First char must be alpha + return NS_ERROR_MALFORMED_URI; + } + + while (p.CheckChar(net_IsValidSchemeChar) || p.CheckWhite()) { + // Skip valid scheme characters or \r\n\t + } + + if (!p.CheckChar(':')) { + return NS_ERROR_MALFORMED_URI; + } + + p.Claim(scheme); + scheme.StripTaggedASCII(ASCIIMask::MaskCRLFTab()); + ToLowerCase(scheme); + return NS_OK; +} + +bool net_IsValidScheme(const nsACString& scheme) { + return mozilla::net::rust_net_is_valid_scheme(&scheme); +} + +bool net_IsAbsoluteURL(const nsACString& uri) { + nsACString::const_iterator start, end; + uri.BeginReading(start); + uri.EndReading(end); + + // Strip C0 and space from begining + while (start != end) { + if ((uint8_t)*start > 0x20) { + break; + } + start++; + } + + Tokenizer p(Substring(start, end), "\r\n\t"); + + // First char must be alpha + if (!p.CheckChar(IsAsciiAlpha)) { + return false; + } + + while (p.CheckChar(net_IsValidSchemeChar) || p.CheckWhite()) { + // Skip valid scheme characters or \r\n\t + } + if (!p.CheckChar(':')) { + return false; + } + p.SkipWhites(); + + if (!p.CheckChar('/')) { + return false; + } + p.SkipWhites(); + + if (p.CheckChar('/')) { + // aSpec is really absolute. Ignore aBaseURI in this case + return true; + } + return false; +} + +void net_FilterURIString(const nsACString& input, nsACString& result) { + result.Truncate(); + + auto start = input.BeginReading(); + auto end = input.EndReading(); + + // Trim off leading and trailing invalid chars. + auto charFilter = [](char c) { return static_cast<uint8_t>(c) > 0x20; }; + auto newStart = std::find_if(start, end, charFilter); + auto newEnd = + std::find_if(std::reverse_iterator<decltype(end)>(end), + std::reverse_iterator<decltype(newStart)>(newStart), + charFilter) + .base(); + + // Check if chars need to be stripped. + bool needsStrip = false; + const ASCIIMaskArray& mask = ASCIIMask::MaskCRLFTab(); + for (auto itr = start; itr != end; ++itr) { + if (ASCIIMask::IsMasked(mask, *itr)) { + needsStrip = true; + break; + } + } + + // Just use the passed in string rather than creating new copies if no + // changes are necessary. + if (newStart == start && newEnd == end && !needsStrip) { + result = input; + return; + } + + result.Assign(Substring(newStart, newEnd)); + if (needsStrip) { + result.StripTaggedASCII(mask); + } +} + +nsresult net_FilterAndEscapeURI(const nsACString& aInput, uint32_t aFlags, + nsACString& aResult) { + aResult.Truncate(); + + auto start = aInput.BeginReading(); + auto end = aInput.EndReading(); + + // Trim off leading and trailing invalid chars. + auto charFilter = [](char c) { return static_cast<uint8_t>(c) > 0x20; }; + auto newStart = std::find_if(start, end, charFilter); + auto newEnd = + std::find_if(std::reverse_iterator<decltype(end)>(end), + std::reverse_iterator<decltype(newStart)>(newStart), + charFilter) + .base(); + + const ASCIIMaskArray& mask = ASCIIMask::MaskCRLFTab(); + return NS_EscapeAndFilterURL(Substring(newStart, newEnd), aFlags, &mask, + aResult, fallible); +} + +#if defined(XP_WIN) +bool net_NormalizeFileURL(const nsACString& aURL, nsCString& aResultBuf) { + bool writing = false; + + nsACString::const_iterator beginIter, endIter; + aURL.BeginReading(beginIter); + aURL.EndReading(endIter); + + const char *s, *begin = beginIter.get(); + + for (s = begin; s != endIter.get(); ++s) { + if (*s == '\\') { + writing = true; + if (s > begin) aResultBuf.Append(begin, s - begin); + aResultBuf += '/'; + begin = s + 1; + } + } + if (writing && s > begin) aResultBuf.Append(begin, s - begin); + + return writing; +} +#endif + +//---------------------------------------------------------------------------- +// miscellaneous (i.e., stuff that should really be elsewhere) +//---------------------------------------------------------------------------- + +static inline void ToLower(char& c) { + if ((unsigned)(c - 'A') <= (unsigned)('Z' - 'A')) c += 'a' - 'A'; +} + +void net_ToLowerCase(char* str, uint32_t length) { + for (char* end = str + length; str < end; ++str) ToLower(*str); +} + +void net_ToLowerCase(char* str) { + for (; *str; ++str) ToLower(*str); +} + +char* net_FindCharInSet(const char* iter, const char* stop, const char* set) { + for (; iter != stop && *iter; ++iter) { + for (const char* s = set; *s; ++s) { + if (*iter == *s) return (char*)iter; + } + } + return (char*)iter; +} + +char* net_FindCharNotInSet(const char* iter, const char* stop, + const char* set) { +repeat: + for (const char* s = set; *s; ++s) { + if (*iter == *s) { + if (++iter == stop) break; + goto repeat; + } + } + return (char*)iter; +} + +char* net_RFindCharNotInSet(const char* stop, const char* iter, + const char* set) { + --iter; + --stop; + + if (iter == stop) return (char*)iter; + +repeat: + for (const char* s = set; *s; ++s) { + if (*iter == *s) { + if (--iter == stop) break; + goto repeat; + } + } + return (char*)iter; +} + +#define HTTP_LWS " \t" + +// Return the index of the closing quote of the string, if any +static uint32_t net_FindStringEnd(const nsCString& flatStr, + uint32_t stringStart, char stringDelim) { + NS_ASSERTION(stringStart < flatStr.Length() && + flatStr.CharAt(stringStart) == stringDelim && + (stringDelim == '"' || stringDelim == '\''), + "Invalid stringStart"); + + const char set[] = {stringDelim, '\\', '\0'}; + do { + // stringStart points to either the start quote or the last + // escaped char (the char following a '\\') + + // Write to searchStart here, so that when we get back to the + // top of the loop right outside this one we search from the + // right place. + uint32_t stringEnd = flatStr.FindCharInSet(set, stringStart + 1); + if (stringEnd == uint32_t(kNotFound)) return flatStr.Length(); + + if (flatStr.CharAt(stringEnd) == '\\') { + // Hit a backslash-escaped char. Need to skip over it. + stringStart = stringEnd + 1; + if (stringStart == flatStr.Length()) return stringStart; + + // Go back to looking for the next escape or the string end + continue; + } + + return stringEnd; + + } while (true); + + MOZ_ASSERT_UNREACHABLE("How did we get here?"); + return flatStr.Length(); +} + +static uint32_t net_FindMediaDelimiter(const nsCString& flatStr, + uint32_t searchStart, char delimiter) { + do { + // searchStart points to the spot from which we should start looking + // for the delimiter. + const char delimStr[] = {delimiter, '"', '\0'}; + uint32_t curDelimPos = flatStr.FindCharInSet(delimStr, searchStart); + if (curDelimPos == uint32_t(kNotFound)) return flatStr.Length(); + + char ch = flatStr.CharAt(curDelimPos); + if (ch == delimiter) { + // Found delimiter + return curDelimPos; + } + + // We hit the start of a quoted string. Look for its end. + searchStart = net_FindStringEnd(flatStr, curDelimPos, ch); + if (searchStart == flatStr.Length()) return searchStart; + + ++searchStart; + + // searchStart now points to the first char after the end of the + // string, so just go back to the top of the loop and look for + // |delimiter| again. + } while (true); + + MOZ_ASSERT_UNREACHABLE("How did we get here?"); + return flatStr.Length(); +} + +// aOffset should be added to aCharsetStart and aCharsetEnd if this +// function sets them. +static void net_ParseMediaType(const nsACString& aMediaTypeStr, + nsACString& aContentType, + nsACString& aContentCharset, int32_t aOffset, + bool* aHadCharset, int32_t* aCharsetStart, + int32_t* aCharsetEnd, bool aStrict) { + const nsCString& flatStr = PromiseFlatCString(aMediaTypeStr); + const char* start = flatStr.get(); + const char* end = start + flatStr.Length(); + + // Trim LWS leading and trailing whitespace from type. We include '(' in + // the trailing trim set to catch media-type comments, which are not at all + // standard, but may occur in rare cases. + const char* type = net_FindCharNotInSet(start, end, HTTP_LWS); + const char* typeEnd = net_FindCharInSet(type, end, HTTP_LWS ";("); + + const char* charset = ""; + const char* charsetEnd = charset; + int32_t charsetParamStart = 0; + int32_t charsetParamEnd = 0; + + uint32_t consumed = typeEnd - type; + + // Iterate over parameters + bool typeHasCharset = false; + uint32_t paramStart = flatStr.FindChar(';', typeEnd - start); + if (paramStart != uint32_t(kNotFound)) { + // We have parameters. Iterate over them. + uint32_t curParamStart = paramStart + 1; + do { + uint32_t curParamEnd = + net_FindMediaDelimiter(flatStr, curParamStart, ';'); + + const char* paramName = net_FindCharNotInSet( + start + curParamStart, start + curParamEnd, HTTP_LWS); + static const char charsetStr[] = "charset="; + if (PL_strncasecmp(paramName, charsetStr, sizeof(charsetStr) - 1) == 0) { + charset = paramName + sizeof(charsetStr) - 1; + charsetEnd = start + curParamEnd; + typeHasCharset = true; + charsetParamStart = curParamStart - 1; + charsetParamEnd = curParamEnd; + } + + consumed = curParamEnd; + curParamStart = curParamEnd + 1; + } while (curParamStart < flatStr.Length()); + } + + bool charsetNeedsQuotedStringUnescaping = false; + if (typeHasCharset) { + // Trim LWS leading and trailing whitespace from charset. We include + // '(' in the trailing trim set to catch media-type comments, which are + // not at all standard, but may occur in rare cases. + charset = net_FindCharNotInSet(charset, charsetEnd, HTTP_LWS); + if (*charset == '"') { + charsetNeedsQuotedStringUnescaping = true; + charsetEnd = + start + net_FindStringEnd(flatStr, charset - start, *charset); + charset++; + NS_ASSERTION(charsetEnd >= charset, "Bad charset parsing"); + } else { + charsetEnd = net_FindCharInSet(charset, charsetEnd, HTTP_LWS ";("); + } + } + + // if the server sent "*/*", it is meaningless, so do not store it. + // also, if type is the same as aContentType, then just update the + // charset. however, if charset is empty and aContentType hasn't + // changed, then don't wipe-out an existing aContentCharset. We + // also want to reject a mime-type if it does not include a slash. + // some servers give junk after the charset parameter, which may + // include a comma, so this check makes us a bit more tolerant. + + if (type != typeEnd && memchr(type, '/', typeEnd - type) != nullptr && + (aStrict ? (net_FindCharNotInSet(start + consumed, end, HTTP_LWS) == end) + : (strncmp(type, "*/*", typeEnd - type) != 0))) { + // Common case here is that aContentType is empty + bool eq = !aContentType.IsEmpty() && + aContentType.Equals(Substring(type, typeEnd), + nsCaseInsensitiveCStringComparator); + if (!eq) { + aContentType.Assign(type, typeEnd - type); + ToLowerCase(aContentType); + } + + if ((!eq && *aHadCharset) || typeHasCharset) { + *aHadCharset = true; + if (charsetNeedsQuotedStringUnescaping) { + // parameters using the "quoted-string" syntax need + // backslash-escapes to be unescaped (see RFC 2616 Section 2.2) + aContentCharset.Truncate(); + for (const char* c = charset; c != charsetEnd; c++) { + if (*c == '\\' && c + 1 != charsetEnd) { + // eat escape + c++; + } + aContentCharset.Append(*c); + } + } else { + aContentCharset.Assign(charset, charsetEnd - charset); + } + if (typeHasCharset) { + *aCharsetStart = charsetParamStart + aOffset; + *aCharsetEnd = charsetParamEnd + aOffset; + } + } + // Only set a new charset position if this is a different type + // from the last one we had and it doesn't already have a + // charset param. If this is the same type, we probably want + // to leave the charset position on its first occurrence. + if (!eq && !typeHasCharset) { + int32_t charsetStart = int32_t(paramStart); + if (charsetStart == kNotFound) charsetStart = flatStr.Length(); + + *aCharsetEnd = *aCharsetStart = charsetStart + aOffset; + } + } +} + +#undef HTTP_LWS + +void net_ParseContentType(const nsACString& aHeaderStr, + nsACString& aContentType, nsACString& aContentCharset, + bool* aHadCharset) { + int32_t dummy1, dummy2; + net_ParseContentType(aHeaderStr, aContentType, aContentCharset, aHadCharset, + &dummy1, &dummy2); +} + +void net_ParseContentType(const nsACString& aHeaderStr, + nsACString& aContentType, nsACString& aContentCharset, + bool* aHadCharset, int32_t* aCharsetStart, + int32_t* aCharsetEnd) { + // + // Augmented BNF (from RFC 2616 section 3.7): + // + // header-value = media-type *( LWS "," LWS media-type ) + // media-type = type "/" subtype *( LWS ";" LWS parameter ) + // type = token + // subtype = token + // parameter = attribute "=" value + // attribute = token + // value = token | quoted-string + // + // + // Examples: + // + // text/html + // text/html, text/html + // text/html,text/html; charset=ISO-8859-1 + // text/html,text/html; charset="ISO-8859-1" + // text/html;charset=ISO-8859-1, text/html + // text/html;charset='ISO-8859-1', text/html + // application/octet-stream + // + + *aHadCharset = false; + const nsCString& flatStr = PromiseFlatCString(aHeaderStr); + + // iterate over media-types. Note that ',' characters can happen + // inside quoted strings, so we need to watch out for that. + uint32_t curTypeStart = 0; + do { + // curTypeStart points to the start of the current media-type. We want + // to look for its end. + uint32_t curTypeEnd = net_FindMediaDelimiter(flatStr, curTypeStart, ','); + + // At this point curTypeEnd points to the spot where the media-type + // starting at curTypeEnd ends. Time to parse that! + net_ParseMediaType( + Substring(flatStr, curTypeStart, curTypeEnd - curTypeStart), + aContentType, aContentCharset, curTypeStart, aHadCharset, aCharsetStart, + aCharsetEnd, false); + + // And let's move on to the next media-type + curTypeStart = curTypeEnd + 1; + } while (curTypeStart < flatStr.Length()); +} + +void net_ParseRequestContentType(const nsACString& aHeaderStr, + nsACString& aContentType, + nsACString& aContentCharset, + bool* aHadCharset) { + // + // Augmented BNF (from RFC 7231 section 3.1.1.1): + // + // media-type = type "/" subtype *( OWS ";" OWS parameter ) + // type = token + // subtype = token + // parameter = token "=" ( token / quoted-string ) + // + // Examples: + // + // text/html + // text/html; charset=ISO-8859-1 + // text/html; charset="ISO-8859-1" + // application/octet-stream + // + + aContentType.Truncate(); + aContentCharset.Truncate(); + *aHadCharset = false; + const nsCString& flatStr = PromiseFlatCString(aHeaderStr); + + // At this point curTypeEnd points to the spot where the media-type + // starting at curTypeEnd ends. Time to parse that! + nsAutoCString contentType, contentCharset; + bool hadCharset = false; + int32_t dummy1, dummy2; + uint32_t typeEnd = net_FindMediaDelimiter(flatStr, 0, ','); + if (typeEnd != flatStr.Length()) { + // We have some stuff left at the end, so this is not a valid + // request Content-Type header. + return; + } + net_ParseMediaType(flatStr, contentType, contentCharset, 0, &hadCharset, + &dummy1, &dummy2, true); + + aContentType = contentType; + aContentCharset = contentCharset; + *aHadCharset = hadCharset; +} + +bool net_IsValidHostName(const nsACString& host) { + const char* end = host.EndReading(); + // Use explicit whitelists to select which characters we are + // willing to send to lower-level DNS logic. This is more + // self-documenting, and can also be slightly faster than the + // blacklist approach, since DNS names are the common case, and + // the commonest characters will tend to be near the start of + // the list. + + // Whitelist for DNS names (RFC 1035) with extra characters added + // for pragmatic reasons "$+_" + // see https://bugzilla.mozilla.org/show_bug.cgi?id=355181#c2 + if (net_FindCharNotInSet(host.BeginReading(), end, + "abcdefghijklmnopqrstuvwxyz" + ".-0123456789" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ$+_") == end) + return true; + + // Might be a valid IPv6 link-local address containing a percent sign + nsAutoCString strhost(host); + PRNetAddr addr; + return PR_StringToNetAddr(strhost.get(), &addr) == PR_SUCCESS; +} + +bool net_IsValidIPv4Addr(const nsACString& aAddr) { + return mozilla::net::rust_net_is_valid_ipv4_addr(&aAddr); +} + +bool net_IsValidIPv6Addr(const nsACString& aAddr) { + return mozilla::net::rust_net_is_valid_ipv6_addr(&aAddr); +} + +namespace mozilla { +static auto MakeNameMatcher(const nsAString& aName) { + return [&aName](const auto& param) { return param.mKey.Equals(aName); }; +} + +bool URLParams::Has(const nsAString& aName) { + return std::any_of(mParams.cbegin(), mParams.cend(), MakeNameMatcher(aName)); +} + +void URLParams::Get(const nsAString& aName, nsString& aRetval) { + SetDOMStringToNull(aRetval); + + const auto end = mParams.cend(); + const auto it = std::find_if(mParams.cbegin(), end, MakeNameMatcher(aName)); + if (it != end) { + aRetval.Assign(it->mValue); + } +} + +void URLParams::GetAll(const nsAString& aName, nsTArray<nsString>& aRetval) { + aRetval.Clear(); + + for (uint32_t i = 0, len = mParams.Length(); i < len; ++i) { + if (mParams[i].mKey.Equals(aName)) { + aRetval.AppendElement(mParams[i].mValue); + } + } +} + +void URLParams::Append(const nsAString& aName, const nsAString& aValue) { + Param* param = mParams.AppendElement(); + param->mKey = aName; + param->mValue = aValue; +} + +void URLParams::Set(const nsAString& aName, const nsAString& aValue) { + Param* param = nullptr; + for (uint32_t i = 0, len = mParams.Length(); i < len;) { + if (!mParams[i].mKey.Equals(aName)) { + ++i; + continue; + } + if (!param) { + param = &mParams[i]; + ++i; + continue; + } + // Remove duplicates. + mParams.RemoveElementAt(i); + --len; + } + + if (!param) { + param = mParams.AppendElement(); + param->mKey = aName; + } + + param->mValue = aValue; +} + +void URLParams::Delete(const nsAString& aName) { + mParams.RemoveElementsBy( + [&aName](const auto& param) { return param.mKey.Equals(aName); }); +} + +/* static */ +void URLParams::ConvertString(const nsACString& aInput, nsAString& aOutput) { + if (NS_FAILED(UTF_8_ENCODING->DecodeWithoutBOMHandling(aInput, aOutput))) { + MOZ_CRASH("Out of memory when converting URL params."); + } +} + +/* static */ +void URLParams::DecodeString(const nsACString& aInput, nsAString& aOutput) { + const char* const end = aInput.EndReading(); + + nsAutoCString unescaped; + + for (const char* iter = aInput.BeginReading(); iter != end;) { + // replace '+' with U+0020 + if (*iter == '+') { + unescaped.Append(' '); + ++iter; + continue; + } + + // Percent decode algorithm + if (*iter == '%') { + const char* const first = iter + 1; + const char* const second = first + 1; + + const auto asciiHexDigit = [](char x) { + return (x >= 0x41 && x <= 0x46) || (x >= 0x61 && x <= 0x66) || + (x >= 0x30 && x <= 0x39); + }; + + const auto hexDigit = [](char x) { + return x >= 0x30 && x <= 0x39 + ? x - 0x30 + : (x >= 0x41 && x <= 0x46 ? x - 0x37 : x - 0x57); + }; + + if (first != end && second != end && asciiHexDigit(*first) && + asciiHexDigit(*second)) { + unescaped.Append(hexDigit(*first) * 16 + hexDigit(*second)); + iter = second + 1; + } else { + unescaped.Append('%'); + ++iter; + } + + continue; + } + + unescaped.Append(*iter); + ++iter; + } + + // XXX It seems rather wasteful to first decode into a UTF-8 nsCString and + // then convert the whole string to UTF-16, at least if we exceed the inline + // storage size. + ConvertString(unescaped, aOutput); +} + +/* static */ +bool URLParams::ParseNextInternal(const char*& aStart, const char* const aEnd, + nsAString* aOutDecodedName, + nsAString* aOutDecodedValue) { + nsDependentCSubstring string; + + const char* const iter = std::find(aStart, aEnd, '&'); + if (iter != aEnd) { + string.Rebind(aStart, iter); + aStart = iter + 1; + } else { + string.Rebind(aStart, aEnd); + aStart = aEnd; + } + + if (string.IsEmpty()) { + return false; + } + + const auto* const eqStart = string.BeginReading(); + const auto* const eqEnd = string.EndReading(); + const auto* const eqIter = std::find(eqStart, eqEnd, '='); + + nsDependentCSubstring name; + nsDependentCSubstring value; + + if (eqIter != eqEnd) { + name.Rebind(eqStart, eqIter); + value.Rebind(eqIter + 1, eqEnd); + } else { + name.Rebind(string, 0); + } + + DecodeString(name, *aOutDecodedName); + DecodeString(value, *aOutDecodedValue); + + return true; +} + +/* static */ +bool URLParams::Extract(const nsACString& aInput, const nsAString& aName, + nsAString& aValue) { + aValue.SetIsVoid(true); + return !URLParams::Parse( + aInput, [&aName, &aValue](const nsAString& name, nsString&& value) { + if (aName == name) { + aValue = std::move(value); + return false; + } + return true; + }); +} + +void URLParams::ParseInput(const nsACString& aInput) { + // Remove all the existing data before parsing a new input. + DeleteAll(); + + URLParams::Parse(aInput, [this](nsString&& name, nsString&& value) { + mParams.AppendElement(Param{std::move(name), std::move(value)}); + return true; + }); +} + +namespace { + +void SerializeString(const nsCString& aInput, nsAString& aValue) { + const unsigned char* p = (const unsigned char*)aInput.get(); + const unsigned char* end = p + aInput.Length(); + + while (p != end) { + // ' ' to '+' + if (*p == 0x20) { + aValue.Append(0x2B); + // Percent Encode algorithm + } else if (*p == 0x2A || *p == 0x2D || *p == 0x2E || + (*p >= 0x30 && *p <= 0x39) || (*p >= 0x41 && *p <= 0x5A) || + *p == 0x5F || (*p >= 0x61 && *p <= 0x7A)) { + aValue.Append(*p); + } else { + aValue.AppendPrintf("%%%.2X", *p); + } + + ++p; + } +} + +} // namespace + +void URLParams::Serialize(nsAString& aValue) const { + aValue.Truncate(); + bool first = true; + + for (uint32_t i = 0, len = mParams.Length(); i < len; ++i) { + if (first) { + first = false; + } else { + aValue.Append('&'); + } + + // XXX Actually, it's not necessary to build a new string object. Generally, + // such cases could just convert each codepoint one-by-one. + SerializeString(NS_ConvertUTF16toUTF8(mParams[i].mKey), aValue); + aValue.Append('='); + SerializeString(NS_ConvertUTF16toUTF8(mParams[i].mValue), aValue); + } +} + +void URLParams::Sort() { + mParams.StableSort([](const Param& lhs, const Param& rhs) { + return Compare(lhs.mKey, rhs.mKey); + }); +} + +} // namespace mozilla diff --git a/netwerk/base/nsURLHelper.h b/netwerk/base/nsURLHelper.h new file mode 100644 index 0000000000..bd850cb01b --- /dev/null +++ b/netwerk/base/nsURLHelper.h @@ -0,0 +1,355 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef nsURLHelper_h__ +#define nsURLHelper_h__ + +#include "nsString.h" +#include "nsTArray.h" + +class nsIFile; +class nsIURLParser; + +enum netCoalesceFlags { + NET_COALESCE_NORMAL = 0, + + /** + * retains /../ that reach above dir root (useful for FTP + * servers in which the root of the FTP URL is not necessarily + * the root of the FTP filesystem). + */ + NET_COALESCE_ALLOW_RELATIVE_ROOT = 1 << 0, + + /** + * recognizes /%2F and // as markers for the root directory + * and handles them properly. + */ + NET_COALESCE_DOUBLE_SLASH_IS_ROOT = 1 << 1 +}; + +//---------------------------------------------------------------------------- +// This module contains some private helper functions related to URL parsing. +//---------------------------------------------------------------------------- + +/* shutdown frees URL parser */ +void net_ShutdownURLHelper(); +#ifdef XP_MACOSX +void net_ShutdownURLHelperOSX(); +#endif + +/* access URL parsers */ +nsIURLParser* net_GetAuthURLParser(); +nsIURLParser* net_GetNoAuthURLParser(); +nsIURLParser* net_GetStdURLParser(); + +/* convert between nsIFile and file:// URL spec + * net_GetURLSpecFromFile does an extra stat, so callers should + * avoid it if possible in favor of net_GetURLSpecFromActualFile + * and net_GetURLSpecFromDir */ +nsresult net_GetURLSpecFromFile(nsIFile*, nsACString&); +nsresult net_GetURLSpecFromDir(nsIFile*, nsACString&); +nsresult net_GetURLSpecFromActualFile(nsIFile*, nsACString&); +nsresult net_GetFileFromURLSpec(const nsACString&, nsIFile**); + +/* extract file path components from file:// URL */ +nsresult net_ParseFileURL(const nsACString& inURL, nsACString& outDirectory, + nsACString& outFileBaseName, + nsACString& outFileExtension); + +/* handle .. in dirs while resolving URLs (path is UTF-8) */ +void net_CoalesceDirs(netCoalesceFlags flags, char* path); + +/** + * Check if a URL is absolute + * + * @param inURL URL spec + * @return true if the given spec represents an absolute URL + */ +bool net_IsAbsoluteURL(const nsACString& inURL); + +/** + * Extract URI-Scheme if possible + * + * @param inURI URI spec + * @param scheme scheme copied to this buffer on return. Is lowercase. + */ +nsresult net_ExtractURLScheme(const nsACString& inURI, nsACString& scheme); + +/* check that the given scheme conforms to RFC 2396 */ +bool net_IsValidScheme(const nsACString& scheme); + +/** + * This function strips out all C0 controls and space at the beginning and end + * of the URL and filters out \r, \n, \t from the middle of the URL. This makes + * it safe to call on things like javascript: urls or data: urls, where we may + * in fact run into whitespace that is not properly encoded. + * + * @param input the URL spec we want to filter + * @param result the out param to write to if filtering happens + */ +void net_FilterURIString(const nsACString& input, nsACString& result); + +/** + * This function performs character stripping just like net_FilterURIString, + * with the added benefit of also performing percent escaping of dissallowed + * characters, all in one pass. Saving one pass is very important when operating + * on really large strings. + * + * @param aInput the URL spec we want to filter + * @param aFlags the flags which control which characters we escape + * @param aResult the out param to write to if filtering happens + */ +nsresult net_FilterAndEscapeURI(const nsACString& aInput, uint32_t aFlags, + nsACString& aResult); + +#if defined(XP_WIN) +/** + * On Win32 and OS/2 system's a back-slash in a file:// URL is equivalent to a + * forward-slash. This function maps any back-slashes to forward-slashes. + * + * @param aURL + * The URL string to normalize (UTF-8 encoded). This can be a + * relative URL segment. + * @param aResultBuf + * The resulting string is appended to this string. If the input URL + * is already normalized, then aResultBuf is unchanged. + * + * @returns false if aURL is already normalized. Otherwise, returns true. + */ +bool net_NormalizeFileURL(const nsACString& aURL, nsCString& aResultBuf); +#endif + +/***************************************************************************** + * generic string routines follow (XXX move to someplace more generic). + */ + +/* convert to lower case */ +void net_ToLowerCase(char* str, uint32_t length); +void net_ToLowerCase(char* str); + +/** + * returns pointer to first character of |str| in the given set. if not found, + * then |end| is returned. stops prematurely if a null byte is encountered, + * and returns the address of the null byte. + */ +char* net_FindCharInSet(const char* str, const char* end, const char* set); + +/** + * returns pointer to first character of |str| NOT in the given set. if all + * characters are in the given set, then |end| is returned. if '\0' is not + * included in |set|, then stops prematurely if a null byte is encountered, + * and returns the address of the null byte. + */ +char* net_FindCharNotInSet(const char* str, const char* end, const char* set); + +/** + * returns pointer to last character of |str| NOT in the given set. if all + * characters are in the given set, then |str - 1| is returned. + */ +char* net_RFindCharNotInSet(const char* str, const char* end, const char* set); + +/** + * Parses a content-type header and returns the content type and + * charset (if any). aCharset is not modified if no charset is + * specified in anywhere in aHeaderStr. In that case (no charset + * specified), aHadCharset is set to false. Otherwise, it's set to + * true. Note that aContentCharset can be empty even if aHadCharset + * is true. + * + * This parsing is suitable for HTTP request. Use net_ParseContentType + * for parsing this header in HTTP responses. + */ +void net_ParseRequestContentType(const nsACString& aHeaderStr, + nsACString& aContentType, + nsACString& aContentCharset, + bool* aHadCharset); + +/** + * Parses a content-type header and returns the content type and + * charset (if any). aCharset is not modified if no charset is + * specified in anywhere in aHeaderStr. In that case (no charset + * specified), aHadCharset is set to false. Otherwise, it's set to + * true. Note that aContentCharset can be empty even if aHadCharset + * is true. + */ +void net_ParseContentType(const nsACString& aHeaderStr, + nsACString& aContentType, nsACString& aContentCharset, + bool* aHadCharset); +/** + * As above, but also returns the start and end indexes for the charset + * parameter in aHeaderStr. These are indices for the entire parameter, NOT + * just the value. If there is "effectively" no charset parameter (e.g. if an + * earlier type with one is overridden by a later type without one), + * *aHadCharset will be true but *aCharsetStart will be set to -1. Note that + * it's possible to have aContentCharset empty and *aHadCharset true when + * *aCharsetStart is nonnegative; this corresponds to charset="". + */ +void net_ParseContentType(const nsACString& aHeaderStr, + nsACString& aContentType, nsACString& aContentCharset, + bool* aHadCharset, int32_t* aCharsetStart, + int32_t* aCharsetEnd); + +/* inline versions */ + +/* remember the 64-bit platforms ;-) */ +#define NET_MAX_ADDRESS ((char*)UINTPTR_MAX) + +inline char* net_FindCharInSet(const char* str, const char* set) { + return net_FindCharInSet(str, NET_MAX_ADDRESS, set); +} +inline char* net_FindCharNotInSet(const char* str, const char* set) { + return net_FindCharNotInSet(str, NET_MAX_ADDRESS, set); +} +inline char* net_RFindCharNotInSet(const char* str, const char* set) { + return net_RFindCharNotInSet(str, str + strlen(str), set); +} + +/** + * This function returns true if the given hostname does not include any + * restricted characters. Otherwise, false is returned. + */ +bool net_IsValidHostName(const nsACString& host); + +/** + * Checks whether the IPv4 address is valid according to RFC 3986 section 3.2.2. + */ +bool net_IsValidIPv4Addr(const nsACString& aAddr); + +/** + * Checks whether the IPv6 address is valid according to RFC 3986 section 3.2.2. + */ +bool net_IsValidIPv6Addr(const nsACString& aAddr); + +namespace mozilla { +/** + * A class for handling form-urlencoded query strings. + * + * Manages an ordered list of name-value pairs, and allows conversion from and + * to the string representation. + * + * In addition, there are static functions for handling one-shot use cases. + */ +class URLParams final { + public: + /** + * \brief Parses a query string and calls a parameter handler for each + * name/value pair. The parameter handler can stop processing early by + * returning false. + * + * \param aInput the query string to parse + * \param aParamHandler the parameter handler as desribed above + * \tparam ParamHandler a function type compatible with signature + * bool(nsString, nsString) + * + * \return false if the parameter handler returned false for any parameter, + * true otherwise + */ + template <typename ParamHandler> + static bool Parse(const nsACString& aInput, ParamHandler aParamHandler) { + const char* start = aInput.BeginReading(); + const char* const end = aInput.EndReading(); + + while (start != end) { + nsAutoString decodedName; + nsAutoString decodedValue; + + if (!ParseNextInternal(start, end, &decodedName, &decodedValue)) { + continue; + } + + if (!aParamHandler(std::move(decodedName), std::move(decodedValue))) { + return false; + } + } + return true; + } + + /** + * \brief Parses a query string and returns the value of a single parameter + * specified by name. + * + * If there are multiple parameters with the same name, the value of the first + * is returned. + * + * \param aInput the query string to parse + * \param aName the name of the parameter to extract + * \param[out] aValue will be assigned the parameter value, set to void if + * there is no match \return true iff there was a parameter with with name + * \paramref aName + */ + static bool Extract(const nsACString& aInput, const nsAString& aName, + nsAString& aValue); + + /** + * \brief Resets the state of this instance and parses a new query string. + * + * \param aInput the query string to parse + */ + void ParseInput(const nsACString& aInput); + + /** + * Serializes the current state to a query string. + */ + void Serialize(nsAString& aValue) const; + + void Get(const nsAString& aName, nsString& aRetval); + + void GetAll(const nsAString& aName, nsTArray<nsString>& aRetval); + + /** + * \brief Sets the value of a given parameter. + * + * If one or more parameters of the name exist, the value of the first is + * replaced, and all further parameters of the name are deleted. Otherwise, + * the behaviour is the same as \ref Append. + */ + void Set(const nsAString& aName, const nsAString& aValue); + + void Append(const nsAString& aName, const nsAString& aValue); + + bool Has(const nsAString& aName); + + /** + * \brief Deletes all parameters with the given name. + */ + void Delete(const nsAString& aName); + + void DeleteAll() { mParams.Clear(); } + + uint32_t Length() const { return mParams.Length(); } + + const nsAString& GetKeyAtIndex(uint32_t aIndex) const { + MOZ_ASSERT(aIndex < mParams.Length()); + return mParams[aIndex].mKey; + } + + const nsAString& GetValueAtIndex(uint32_t aIndex) const { + MOZ_ASSERT(aIndex < mParams.Length()); + return mParams[aIndex].mValue; + } + + /** + * \brief Performs a stable sort of the parameters, maintaining the order of + * multiple parameters with the same name. + */ + void Sort(); + + private: + static void DecodeString(const nsACString& aInput, nsAString& aOutput); + static void ConvertString(const nsACString& aInput, nsAString& aOutput); + static bool ParseNextInternal(const char*& aStart, const char* aEnd, + nsAString* aOutDecodedName, + nsAString* aOutDecodedValue); + + struct Param { + nsString mKey; + nsString mValue; + }; + + nsTArray<Param> mParams; +}; +} // namespace mozilla + +#endif // !nsURLHelper_h__ diff --git a/netwerk/base/nsURLHelperOSX.cpp b/netwerk/base/nsURLHelperOSX.cpp new file mode 100644 index 0000000000..9a8fbad9a2 --- /dev/null +++ b/netwerk/base/nsURLHelperOSX.cpp @@ -0,0 +1,205 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=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/. */ + +/* Mac OS X-specific local file uri parsing */ +#include "nsURLHelper.h" +#include "nsEscape.h" +#include "nsIFile.h" +#include "nsTArray.h" +#include "nsReadableUtils.h" +#include <Carbon/Carbon.h> + +static nsTArray<nsCString>* gVolumeList = nullptr; + +static bool pathBeginsWithVolName(const nsACString& path, + nsACString& firstPathComponent) { + // Return whether the 1st path component in path (escaped) is equal to the + // name of a mounted volume. Return the 1st path component (unescaped) in any + // case. This needs to be done as quickly as possible, so we cache a list of + // volume names. + // XXX Register an event handler to detect drives being mounted/unmounted? + + if (!gVolumeList) { + gVolumeList = new nsTArray<nsCString>; + if (!gVolumeList) { + return false; // out of memory + } + } + + // Cache a list of volume names + if (!gVolumeList->Length()) { + OSErr err; + ItemCount volumeIndex = 1; + + do { + HFSUniStr255 volName; + FSRef rootDirectory; + err = ::FSGetVolumeInfo(0, volumeIndex, nullptr, kFSVolInfoNone, nullptr, + &volName, &rootDirectory); + if (err == noErr) { + NS_ConvertUTF16toUTF8 volNameStr( + Substring((char16_t*)volName.unicode, + (char16_t*)volName.unicode + volName.length)); + gVolumeList->AppendElement(volNameStr); + volumeIndex++; + } + } while (err == noErr); + } + + // Extract the first component of the path + nsACString::const_iterator start; + path.BeginReading(start); + start.advance(1); // path begins with '/' + nsACString::const_iterator directory_end; + path.EndReading(directory_end); + nsACString::const_iterator component_end(start); + FindCharInReadable('/', component_end, directory_end); + + nsAutoCString flatComponent((Substring(start, component_end))); + NS_UnescapeURL(flatComponent); + int32_t foundIndex = gVolumeList->IndexOf(flatComponent); + firstPathComponent = flatComponent; + return (foundIndex != -1); +} + +void net_ShutdownURLHelperOSX() { + delete gVolumeList; + gVolumeList = nullptr; +} + +static nsresult convertHFSPathtoPOSIX(const nsACString& hfsPath, + nsACString& posixPath) { + // Use CFURL to do the conversion. We don't want to do this by simply + // using SwapSlashColon - we need the charset mapped from MacRoman + // to UTF-8, and we need "/Volumes" (or whatever - Apple says this is subject + // to change) prepended if the path is not on the boot drive. + + CFStringRef pathStrRef = CFStringCreateWithCString( + nullptr, PromiseFlatCString(hfsPath).get(), kCFStringEncodingMacRoman); + if (!pathStrRef) return NS_ERROR_FAILURE; + + nsresult rv = NS_ERROR_FAILURE; + CFURLRef urlRef = CFURLCreateWithFileSystemPath(nullptr, pathStrRef, + kCFURLHFSPathStyle, true); + if (urlRef) { + UInt8 pathBuf[PATH_MAX]; + if (CFURLGetFileSystemRepresentation(urlRef, true, pathBuf, + sizeof(pathBuf))) { + posixPath = (char*)pathBuf; + rv = NS_OK; + } + } + CFRelease(pathStrRef); + if (urlRef) CFRelease(urlRef); + return rv; +} + +static void SwapSlashColon(char* s) { + while (*s) { + if (*s == '/') + *s = ':'; + else if (*s == ':') + *s = '/'; + s++; + } +} + +nsresult net_GetURLSpecFromActualFile(nsIFile* aFile, nsACString& result) { + // NOTE: This is identical to the implementation in nsURLHelperUnix.cpp + + nsresult rv; + nsAutoCString ePath; + + // construct URL spec from native file path + rv = aFile->GetNativePath(ePath); + if (NS_FAILED(rv)) return rv; + + nsAutoCString escPath; + constexpr auto prefix = "file://"_ns; + + // Escape the path with the directory mask + if (NS_EscapeURL(ePath.get(), ePath.Length(), esc_Directory + esc_Forced, + escPath)) + escPath.Insert(prefix, 0); + else + escPath.Assign(prefix + ePath); + + // esc_Directory does not escape the semicolons, so if a filename + // contains semicolons we need to manually escape them. + // This replacement should be removed in bug #473280 + escPath.ReplaceSubstring(";", "%3b"); + + result = escPath; + return NS_OK; +} + +nsresult net_GetFileFromURLSpec(const nsACString& aURL, nsIFile** result) { + // NOTE: See also the implementation in nsURLHelperUnix.cpp + // This matches it except for the HFS path handling. + + nsresult rv; + + nsCOMPtr<nsIFile> localFile; + rv = NS_NewNativeLocalFile(""_ns, true, getter_AddRefs(localFile)); + if (NS_FAILED(rv)) return rv; + + nsAutoCString directory, fileBaseName, fileExtension, path; + bool bHFSPath = false; + + rv = net_ParseFileURL(aURL, directory, fileBaseName, fileExtension); + if (NS_FAILED(rv)) return rv; + + if (!directory.IsEmpty()) { + NS_EscapeURL(directory, esc_Directory | esc_AlwaysCopy, path); + + // The canonical form of file URLs on OSX use POSIX paths: + // file:///path-name. + // But, we still encounter file URLs that use HFS paths: + // file:///volume-name/path-name + // Determine that here and normalize HFS paths to POSIX. + nsAutoCString possibleVolName; + if (pathBeginsWithVolName(directory, possibleVolName)) { + // Though we know it begins with a volume name, it could still + // be a valid POSIX path if the boot drive is named "Mac HD" + // and there is a directory "Mac HD" at its root. If such a + // directory doesn't exist, we'll assume this is an HFS path. + FSRef testRef; + possibleVolName.InsertLiteral("/", 0); + if (::FSPathMakeRef((UInt8*)possibleVolName.get(), &testRef, nullptr) != + noErr) + bHFSPath = true; + } + + if (bHFSPath) { + // "%2F"s need to become slashes, while all other slashes need to + // become colons. If we start out by changing "%2F"s to colons, we + // can reply on SwapSlashColon() to do what we need + path.ReplaceSubstring("%2F", ":"); + path.Cut(0, 1); // directory begins with '/' + SwapSlashColon((char*)path.get()); + // At this point, path is an HFS path made using the same + // algorithm as nsURLHelperMac. We'll convert to POSIX below. + } + } + if (!fileBaseName.IsEmpty()) + NS_EscapeURL(fileBaseName, esc_FileBaseName | esc_AlwaysCopy, path); + if (!fileExtension.IsEmpty()) { + path += '.'; + NS_EscapeURL(fileExtension, esc_FileExtension | esc_AlwaysCopy, path); + } + + NS_UnescapeURL(path); + if (path.Length() != strlen(path.get())) return NS_ERROR_FILE_INVALID_PATH; + + if (bHFSPath) convertHFSPathtoPOSIX(path, path); + + // assuming path is encoded in the native charset + rv = localFile->InitWithNativePath(path); + if (NS_FAILED(rv)) return rv; + + localFile.forget(result); + return NS_OK; +} diff --git a/netwerk/base/nsURLHelperUnix.cpp b/netwerk/base/nsURLHelperUnix.cpp new file mode 100644 index 0000000000..c1eeb36e0b --- /dev/null +++ b/netwerk/base/nsURLHelperUnix.cpp @@ -0,0 +1,105 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=4 sw=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/. */ + +/* Unix-specific local file uri parsing */ +#include "nsURLHelper.h" +#include "nsEscape.h" +#include "nsIFile.h" +#include "nsNativeCharsetUtils.h" +#include "mozilla/Utf8.h" + +using mozilla::IsUtf8; + +nsresult net_GetURLSpecFromActualFile(nsIFile* aFile, nsACString& result) { + nsresult rv; + nsAutoCString nativePath, ePath; + nsAutoString path; + + rv = aFile->GetNativePath(nativePath); + if (NS_FAILED(rv)) return rv; + + // Convert to unicode and back to check correct conversion to native charset + NS_CopyNativeToUnicode(nativePath, path); + NS_CopyUnicodeToNative(path, ePath); + + // Use UTF8 version if conversion was successful + if (nativePath == ePath) + CopyUTF16toUTF8(path, ePath); + else + ePath = nativePath; + + nsAutoCString escPath; + constexpr auto prefix = "file://"_ns; + + // Escape the path with the directory mask + if (NS_EscapeURL(ePath.get(), -1, esc_Directory + esc_Forced, escPath)) + escPath.Insert(prefix, 0); + else + escPath.Assign(prefix + ePath); + + // esc_Directory does not escape the semicolons, so if a filename + // contains semicolons we need to manually escape them. + // This replacement should be removed in bug #473280 + escPath.ReplaceSubstring(";", "%3b"); + result = escPath; + return NS_OK; +} + +nsresult net_GetFileFromURLSpec(const nsACString& aURL, nsIFile** result) { + // NOTE: See also the implementation in nsURLHelperOSX.cpp, + // which is based on this. + + nsresult rv; + + nsCOMPtr<nsIFile> localFile; + rv = NS_NewNativeLocalFile(""_ns, true, getter_AddRefs(localFile)); + if (NS_FAILED(rv)) return rv; + + nsAutoCString directory, fileBaseName, fileExtension, path; + + rv = net_ParseFileURL(aURL, directory, fileBaseName, fileExtension); + if (NS_FAILED(rv)) return rv; + + if (!directory.IsEmpty()) { + rv = NS_EscapeURL(directory, esc_Directory | esc_AlwaysCopy, path, + mozilla::fallible); + if (NS_FAILED(rv)) return rv; + } + if (!fileBaseName.IsEmpty()) { + rv = NS_EscapeURL(fileBaseName, esc_FileBaseName | esc_AlwaysCopy, path, + mozilla::fallible); + if (NS_FAILED(rv)) return rv; + } + if (!fileExtension.IsEmpty()) { + path += '.'; + rv = NS_EscapeURL(fileExtension, esc_FileExtension | esc_AlwaysCopy, path, + mozilla::fallible); + if (NS_FAILED(rv)) return rv; + } + + NS_UnescapeURL(path); + if (path.Length() != strlen(path.get())) return NS_ERROR_FILE_INVALID_PATH; + + if (IsUtf8(path)) { + // speed up the start-up where UTF-8 is the native charset + // (e.g. on recent Linux distributions) + if (NS_IsNativeUTF8()) + rv = localFile->InitWithNativePath(path); + else + rv = localFile->InitWithPath(NS_ConvertUTF8toUTF16(path)); + // XXX In rare cases, a valid UTF-8 string can be valid as a native + // encoding (e.g. 0xC5 0x83 is valid both as UTF-8 and Windows-125x). + // However, the chance is very low that a meaningful word in a legacy + // encoding is valid as UTF-8. + } else + // if path is not in UTF-8, assume it is encoded in the native charset + rv = localFile->InitWithNativePath(path); + + if (NS_FAILED(rv)) return rv; + + localFile.forget(result); + return NS_OK; +} diff --git a/netwerk/base/nsURLHelperWin.cpp b/netwerk/base/nsURLHelperWin.cpp new file mode 100644 index 0000000000..7a4f53978e --- /dev/null +++ b/netwerk/base/nsURLHelperWin.cpp @@ -0,0 +1,111 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=4 sw=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/. */ + +/* Windows-specific local file uri parsing */ +#include "nsComponentManagerUtils.h" +#include "nsURLHelper.h" +#include "nsEscape.h" +#include "nsIFile.h" +#include <windows.h> +#include "mozilla/StaticPrefs_network.h" +#include "mozilla/Utf8.h" + +using namespace mozilla; + +nsresult net_GetURLSpecFromActualFile(nsIFile* aFile, nsACString& result) { + nsresult rv; + nsAutoString path; + + // construct URL spec from file path + rv = aFile->GetPath(path); + if (NS_FAILED(rv)) return rv; + + // Replace \ with / to convert to an url + path.ReplaceChar(char16_t(0x5Cu), char16_t(0x2Fu)); + + nsAutoCString escPath; + + // Windows Desktop paths begin with a drive letter, so need an 'extra' + // slash at the begining + // C:\Windows => file:///C:/Windows + constexpr auto prefix = "file:///"_ns; + + // Escape the path with the directory mask + NS_ConvertUTF16toUTF8 ePath(path); + if (NS_EscapeURL(ePath.get(), -1, esc_Directory + esc_Forced, escPath)) + escPath.Insert(prefix, 0); + else + escPath.Assign(prefix + ePath); + + // esc_Directory does not escape the semicolons, so if a filename + // contains semicolons we need to manually escape them. + // This replacement should be removed in bug #473280 + escPath.ReplaceSubstring(";", "%3b"); + + result = escPath; + return NS_OK; +} + +nsresult net_GetFileFromURLSpec(const nsACString& aURL, nsIFile** result) { + nsresult rv; + + if (aURL.Length() > StaticPrefs::network_standard_url_max_length()) { + return NS_ERROR_MALFORMED_URI; + } + + nsCOMPtr<nsIFile> localFile(do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv)); + if (NS_FAILED(rv)) { + NS_ERROR("Only nsIFile supported right now"); + return rv; + } + + const nsACString* specPtr; + + nsAutoCString buf; + if (net_NormalizeFileURL(aURL, buf)) + specPtr = &buf; + else + specPtr = &aURL; + + nsAutoCString directory, fileBaseName, fileExtension; + + rv = net_ParseFileURL(*specPtr, directory, fileBaseName, fileExtension); + if (NS_FAILED(rv)) return rv; + + nsAutoCString path; + + if (!directory.IsEmpty()) { + NS_EscapeURL(directory, esc_Directory | esc_AlwaysCopy, path); + if (path.Length() > 2 && path.CharAt(2) == '|') path.SetCharAt(':', 2); + path.ReplaceChar('/', '\\'); + } + if (!fileBaseName.IsEmpty()) + NS_EscapeURL(fileBaseName, esc_FileBaseName | esc_AlwaysCopy, path); + if (!fileExtension.IsEmpty()) { + path += '.'; + NS_EscapeURL(fileExtension, esc_FileExtension | esc_AlwaysCopy, path); + } + + NS_UnescapeURL(path); + if (path.Length() != strlen(path.get())) return NS_ERROR_FILE_INVALID_PATH; + + // remove leading '\' + if (path.CharAt(0) == '\\') path.Cut(0, 1); + + if (IsUtf8(path)) rv = localFile->InitWithPath(NS_ConvertUTF8toUTF16(path)); + // XXX In rare cases, a valid UTF-8 string can be valid as a native + // encoding (e.g. 0xC5 0x83 is valid both as UTF-8 and Windows-125x). + // However, the chance is very low that a meaningful word in a legacy + // encoding is valid as UTF-8. + else + // if path is not in UTF-8, assume it is encoded in the native charset + rv = localFile->InitWithNativePath(path); + + if (NS_FAILED(rv)) return rv; + + localFile.forget(result); + return NS_OK; +} diff --git a/netwerk/base/nsURLParsers.cpp b/netwerk/base/nsURLParsers.cpp new file mode 100644 index 0000000000..2ed642230d --- /dev/null +++ b/netwerk/base/nsURLParsers.cpp @@ -0,0 +1,634 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 <string.h> + +#include "mozilla/RangedPtr.h" +#include "mozilla/TextUtils.h" + +#include "nsCRTGlue.h" +#include "nsURLParsers.h" +#include "nsURLHelper.h" +#include "nsString.h" + +using namespace mozilla; + +//---------------------------------------------------------------------------- + +static uint32_t CountConsecutiveSlashes(const char* str, int32_t len) { + RangedPtr<const char> p(str, len); + uint32_t count = 0; + while (len-- && *p++ == '/') ++count; + return count; +} + +//---------------------------------------------------------------------------- +// nsBaseURLParser implementation +//---------------------------------------------------------------------------- + +NS_IMPL_ISUPPORTS(nsAuthURLParser, nsIURLParser) +NS_IMPL_ISUPPORTS(nsNoAuthURLParser, nsIURLParser) + +#define SET_RESULT(component, pos, len) \ + PR_BEGIN_MACRO \ + if (component##Pos) *component##Pos = uint32_t(pos); \ + if (component##Len) *component##Len = int32_t(len); \ + PR_END_MACRO + +#define OFFSET_RESULT(component, offset) \ + PR_BEGIN_MACRO \ + if (component##Pos) *component##Pos += offset; \ + PR_END_MACRO + +NS_IMETHODIMP +nsBaseURLParser::ParseURL(const char* spec, int32_t specLen, + uint32_t* schemePos, int32_t* schemeLen, + uint32_t* authorityPos, int32_t* authorityLen, + uint32_t* pathPos, int32_t* pathLen) { + if (NS_WARN_IF(!spec)) { + return NS_ERROR_INVALID_POINTER; + } + + if (specLen < 0) specLen = strlen(spec); + + const char* stop = nullptr; + const char* colon = nullptr; + const char* slash = nullptr; + const char* p = spec; + uint32_t offset = 0; + int32_t len = specLen; + + // skip leading whitespace + while (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t') { + spec++; + specLen--; + offset++; + + p++; + len--; + } + + for (; len && *p && !colon && !slash; ++p, --len) { + switch (*p) { + case ':': + if (!colon) colon = p; + break; + case '/': // start of filepath + case '?': // start of query + case '#': // start of ref + if (!slash) slash = p; + break; + case '@': // username@hostname + case '[': // start of IPv6 address literal + if (!stop) stop = p; + break; + } + } + // disregard the first colon if it follows an '@' or a '[' + if (colon && stop && colon > stop) colon = nullptr; + + // if the spec only contained whitespace ... + if (specLen == 0) { + SET_RESULT(scheme, 0, -1); + SET_RESULT(authority, 0, 0); + SET_RESULT(path, 0, 0); + return NS_OK; + } + + // ignore trailing whitespace and control characters + for (p = spec + specLen - 1; ((unsigned char)*p <= ' ') && (p != spec); --p) + ; + + specLen = p - spec + 1; + + if (colon && (colon < slash || !slash)) { + // + // spec = <scheme>:/<the-rest> + // + // or + // + // spec = <scheme>:<authority> + // spec = <scheme>:<path-no-slashes> + // + if (!net_IsValidScheme(nsDependentCSubstring(spec, colon - spec)) || + (*(colon + 1) == ':')) { + return NS_ERROR_MALFORMED_URI; + } + SET_RESULT(scheme, offset, colon - spec); + if (authorityLen || pathLen) { + uint32_t schemeLen = colon + 1 - spec; + offset += schemeLen; + ParseAfterScheme(colon + 1, specLen - schemeLen, authorityPos, + authorityLen, pathPos, pathLen); + OFFSET_RESULT(authority, offset); + OFFSET_RESULT(path, offset); + } + } else { + // + // spec = <authority-no-port-or-password>/<path> + // spec = <path> + // + // or + // + // spec = <authority-no-port-or-password>/<path-with-colon> + // spec = <path-with-colon> + // + // or + // + // spec = <authority-no-port-or-password> + // spec = <path-no-slashes-or-colon> + // + SET_RESULT(scheme, 0, -1); + if (authorityLen || pathLen) { + ParseAfterScheme(spec, specLen, authorityPos, authorityLen, pathPos, + pathLen); + OFFSET_RESULT(authority, offset); + OFFSET_RESULT(path, offset); + } + } + return NS_OK; +} + +NS_IMETHODIMP +nsBaseURLParser::ParseAuthority(const char* auth, int32_t authLen, + uint32_t* usernamePos, int32_t* usernameLen, + uint32_t* passwordPos, int32_t* passwordLen, + uint32_t* hostnamePos, int32_t* hostnameLen, + int32_t* port) { + if (NS_WARN_IF(!auth)) { + return NS_ERROR_INVALID_POINTER; + } + + if (authLen < 0) authLen = strlen(auth); + + SET_RESULT(username, 0, -1); + SET_RESULT(password, 0, -1); + SET_RESULT(hostname, 0, authLen); + if (port) *port = -1; + return NS_OK; +} + +NS_IMETHODIMP +nsBaseURLParser::ParseUserInfo(const char* userinfo, int32_t userinfoLen, + uint32_t* usernamePos, int32_t* usernameLen, + uint32_t* passwordPos, int32_t* passwordLen) { + SET_RESULT(username, 0, -1); + SET_RESULT(password, 0, -1); + return NS_OK; +} + +NS_IMETHODIMP +nsBaseURLParser::ParseServerInfo(const char* serverinfo, int32_t serverinfoLen, + uint32_t* hostnamePos, int32_t* hostnameLen, + int32_t* port) { + SET_RESULT(hostname, 0, -1); + if (port) *port = -1; + return NS_OK; +} + +NS_IMETHODIMP +nsBaseURLParser::ParsePath(const char* path, int32_t pathLen, + uint32_t* filepathPos, int32_t* filepathLen, + uint32_t* queryPos, int32_t* queryLen, + uint32_t* refPos, int32_t* refLen) { + if (NS_WARN_IF(!path)) { + return NS_ERROR_INVALID_POINTER; + } + + if (pathLen < 0) pathLen = strlen(path); + + // path = [/]<segment1>/<segment2>/<...>/<segmentN>?<query>#<ref> + + // XXX PL_strnpbrk would be nice, but it's buggy + + // search for first occurrence of either ? or # + const char *query_beg = nullptr, *query_end = nullptr; + const char* ref_beg = nullptr; + const char* p = nullptr; + for (p = path; p < path + pathLen; ++p) { + // only match the query string if it precedes the reference fragment + if (!ref_beg && !query_beg && *p == '?') + query_beg = p + 1; + else if (*p == '#') { + ref_beg = p + 1; + if (query_beg) query_end = p; + break; + } + } + + if (query_beg) { + if (query_end) + SET_RESULT(query, query_beg - path, query_end - query_beg); + else + SET_RESULT(query, query_beg - path, pathLen - (query_beg - path)); + } else + SET_RESULT(query, 0, -1); + + if (ref_beg) + SET_RESULT(ref, ref_beg - path, pathLen - (ref_beg - path)); + else + SET_RESULT(ref, 0, -1); + + const char* end; + if (query_beg) + end = query_beg - 1; + else if (ref_beg) + end = ref_beg - 1; + else + end = path + pathLen; + + // an empty file path is no file path + if (end != path) + SET_RESULT(filepath, 0, end - path); + else + SET_RESULT(filepath, 0, -1); + return NS_OK; +} + +NS_IMETHODIMP +nsBaseURLParser::ParseFilePath(const char* filepath, int32_t filepathLen, + uint32_t* directoryPos, int32_t* directoryLen, + uint32_t* basenamePos, int32_t* basenameLen, + uint32_t* extensionPos, int32_t* extensionLen) { + if (NS_WARN_IF(!filepath)) { + return NS_ERROR_INVALID_POINTER; + } + + if (filepathLen < 0) filepathLen = strlen(filepath); + + if (filepathLen == 0) { + SET_RESULT(directory, 0, -1); + SET_RESULT(basename, 0, 0); // assume a zero length file basename + SET_RESULT(extension, 0, -1); + return NS_OK; + } + + const char* p; + const char* end = filepath + filepathLen; + + // search backwards for filename + for (p = end - 1; *p != '/' && p > filepath; --p) + ; + if (*p == '/') { + // catch /.. and /. + if ((p + 1 < end && *(p + 1) == '.') && + (p + 2 == end || (*(p + 2) == '.' && p + 3 == end))) + p = end - 1; + // filepath = <directory><filename>.<extension> + SET_RESULT(directory, 0, p - filepath + 1); + ParseFileName(p + 1, end - (p + 1), basenamePos, basenameLen, extensionPos, + extensionLen); + OFFSET_RESULT(basename, p + 1 - filepath); + OFFSET_RESULT(extension, p + 1 - filepath); + } else { + // filepath = <filename>.<extension> + SET_RESULT(directory, 0, -1); + ParseFileName(filepath, filepathLen, basenamePos, basenameLen, extensionPos, + extensionLen); + } + return NS_OK; +} + +nsresult nsBaseURLParser::ParseFileName( + const char* filename, int32_t filenameLen, uint32_t* basenamePos, + int32_t* basenameLen, uint32_t* extensionPos, int32_t* extensionLen) { + if (NS_WARN_IF(!filename)) { + return NS_ERROR_INVALID_POINTER; + } + + if (filenameLen < 0) filenameLen = strlen(filename); + + // no extension if filename ends with a '.' + if (filename[filenameLen - 1] != '.') { + // ignore '.' at the beginning + for (const char* p = filename + filenameLen - 1; p > filename; --p) { + if (*p == '.') { + // filename = <basename.extension> + SET_RESULT(basename, 0, p - filename); + SET_RESULT(extension, p + 1 - filename, + filenameLen - (p - filename + 1)); + return NS_OK; + } + } + } + // filename = <basename> + SET_RESULT(basename, 0, filenameLen); + SET_RESULT(extension, 0, -1); + return NS_OK; +} + +//---------------------------------------------------------------------------- +// nsNoAuthURLParser implementation +//---------------------------------------------------------------------------- + +NS_IMETHODIMP +nsNoAuthURLParser::ParseAuthority(const char* auth, int32_t authLen, + uint32_t* usernamePos, int32_t* usernameLen, + uint32_t* passwordPos, int32_t* passwordLen, + uint32_t* hostnamePos, int32_t* hostnameLen, + int32_t* port) { + MOZ_ASSERT_UNREACHABLE("Shouldn't parse auth in a NoAuthURL!"); + return NS_ERROR_UNEXPECTED; +} + +void nsNoAuthURLParser::ParseAfterScheme(const char* spec, int32_t specLen, + uint32_t* authPos, int32_t* authLen, + uint32_t* pathPos, int32_t* pathLen) { + MOZ_ASSERT(specLen >= 0, "unexpected"); + + // everything is the path + uint32_t pos = 0; + switch (CountConsecutiveSlashes(spec, specLen)) { + case 0: + case 1: + break; + case 2: { + const char* p = nullptr; + if (specLen > 2) { + // looks like there is an authority section + + // if the authority looks like a drive number then we + // really want to treat it as part of the path + // [a-zA-Z][:|]{/\} + // i.e one of: c: c:\foo c:/foo c| c|\foo c|/foo + if ((specLen > 3) && (spec[3] == ':' || spec[3] == '|') && + IsAsciiAlpha(spec[2]) && + ((specLen == 4) || (spec[4] == '/') || (spec[4] == '\\'))) { + pos = 1; + break; + } + // Ignore apparent authority; path is everything after it + for (p = spec + 2; p < spec + specLen; ++p) { + if (*p == '/' || *p == '?' || *p == '#') break; + } + } + SET_RESULT(auth, 0, -1); + if (p && p != spec + specLen) + SET_RESULT(path, p - spec, specLen - (p - spec)); + else + SET_RESULT(path, 0, -1); + return; + } + default: + pos = 2; + break; + } + SET_RESULT(auth, pos, 0); + SET_RESULT(path, pos, specLen - pos); +} + +#if defined(XP_WIN) +NS_IMETHODIMP +nsNoAuthURLParser::ParseFilePath(const char* filepath, int32_t filepathLen, + uint32_t* directoryPos, int32_t* directoryLen, + uint32_t* basenamePos, int32_t* basenameLen, + uint32_t* extensionPos, + int32_t* extensionLen) { + if (NS_WARN_IF(!filepath)) { + return NS_ERROR_INVALID_POINTER; + } + + if (filepathLen < 0) filepathLen = strlen(filepath); + + // look for a filepath consisting of only a drive number, which may or + // may not have a leading slash. + if (filepathLen > 1 && filepathLen < 4) { + const char* end = filepath + filepathLen; + const char* p = filepath; + if (*p == '/') p++; + if ((end - p == 2) && (p[1] == ':' || p[1] == '|') && IsAsciiAlpha(*p)) { + // filepath = <drive-number>: + SET_RESULT(directory, 0, filepathLen); + SET_RESULT(basename, 0, -1); + SET_RESULT(extension, 0, -1); + return NS_OK; + } + } + + // otherwise fallback on common implementation + return nsBaseURLParser::ParseFilePath(filepath, filepathLen, directoryPos, + directoryLen, basenamePos, basenameLen, + extensionPos, extensionLen); +} +#endif + +//---------------------------------------------------------------------------- +// nsAuthURLParser implementation +//---------------------------------------------------------------------------- + +NS_IMETHODIMP +nsAuthURLParser::ParseAuthority(const char* auth, int32_t authLen, + uint32_t* usernamePos, int32_t* usernameLen, + uint32_t* passwordPos, int32_t* passwordLen, + uint32_t* hostnamePos, int32_t* hostnameLen, + int32_t* port) { + nsresult rv; + + if (NS_WARN_IF(!auth)) { + return NS_ERROR_INVALID_POINTER; + } + + if (authLen < 0) authLen = strlen(auth); + + if (authLen == 0) { + SET_RESULT(username, 0, -1); + SET_RESULT(password, 0, -1); + SET_RESULT(hostname, 0, 0); + if (port) *port = -1; + return NS_OK; + } + + // search backwards for @ + const char* p = auth + authLen - 1; + for (; (*p != '@') && (p > auth); --p) { + } + if (*p == '@') { + // auth = <user-info@server-info> + rv = ParseUserInfo(auth, p - auth, usernamePos, usernameLen, passwordPos, + passwordLen); + if (NS_FAILED(rv)) return rv; + rv = ParseServerInfo(p + 1, authLen - (p - auth + 1), hostnamePos, + hostnameLen, port); + if (NS_FAILED(rv)) return rv; + OFFSET_RESULT(hostname, p + 1 - auth); + + // malformed if has a username or password + // but no host info, such as: http://u:p@/ + if ((usernamePos || passwordPos) && (!hostnamePos || !*hostnameLen)) { + return NS_ERROR_MALFORMED_URI; + } + } else { + // auth = <server-info> + SET_RESULT(username, 0, -1); + SET_RESULT(password, 0, -1); + rv = ParseServerInfo(auth, authLen, hostnamePos, hostnameLen, port); + if (NS_FAILED(rv)) return rv; + } + return NS_OK; +} + +NS_IMETHODIMP +nsAuthURLParser::ParseUserInfo(const char* userinfo, int32_t userinfoLen, + uint32_t* usernamePos, int32_t* usernameLen, + uint32_t* passwordPos, int32_t* passwordLen) { + if (NS_WARN_IF(!userinfo)) { + return NS_ERROR_INVALID_POINTER; + } + + if (userinfoLen < 0) userinfoLen = strlen(userinfo); + + if (userinfoLen == 0) { + SET_RESULT(username, 0, -1); + SET_RESULT(password, 0, -1); + return NS_OK; + } + + const char* p = (const char*)memchr(userinfo, ':', userinfoLen); + if (p) { + // userinfo = <username:password> + SET_RESULT(username, 0, p - userinfo); + SET_RESULT(password, p - userinfo + 1, userinfoLen - (p - userinfo + 1)); + } else { + // userinfo = <username> + SET_RESULT(username, 0, userinfoLen); + SET_RESULT(password, 0, -1); + } + return NS_OK; +} + +NS_IMETHODIMP +nsAuthURLParser::ParseServerInfo(const char* serverinfo, int32_t serverinfoLen, + uint32_t* hostnamePos, int32_t* hostnameLen, + int32_t* port) { + if (NS_WARN_IF(!serverinfo)) { + return NS_ERROR_INVALID_POINTER; + } + + if (serverinfoLen < 0) serverinfoLen = strlen(serverinfo); + + if (serverinfoLen == 0) { + SET_RESULT(hostname, 0, 0); + if (port) *port = -1; + return NS_OK; + } + + // search backwards for a ':' but stop on ']' (IPv6 address literal + // delimiter). check for illegal characters in the hostname. + const char* p = serverinfo + serverinfoLen - 1; + const char *colon = nullptr, *bracket = nullptr; + for (; p > serverinfo; --p) { + switch (*p) { + case ']': + bracket = p; + break; + case ':': + if (bracket == nullptr) colon = p; + break; + case ' ': + // hostname must not contain a space + return NS_ERROR_MALFORMED_URI; + } + } + + if (colon) { + // serverinfo = <hostname:port> + SET_RESULT(hostname, 0, colon - serverinfo); + if (port) { + // XXX unfortunately ToInteger is not defined for substrings + nsAutoCString buf(colon + 1, serverinfoLen - (colon + 1 - serverinfo)); + if (buf.Length() == 0) { + *port = -1; + } else { + const char* nondigit = NS_strspnp("0123456789", buf.get()); + if (nondigit && *nondigit) return NS_ERROR_MALFORMED_URI; + + nsresult err; + *port = buf.ToInteger(&err); + if (NS_FAILED(err) || *port < 0 || + *port > std::numeric_limits<uint16_t>::max()) + return NS_ERROR_MALFORMED_URI; + } + } + } else { + // serverinfo = <hostname> + SET_RESULT(hostname, 0, serverinfoLen); + if (port) *port = -1; + } + + // In case of IPv6 address check its validity + if (*hostnameLen > 1 && *(serverinfo + *hostnamePos) == '[' && + *(serverinfo + *hostnamePos + *hostnameLen - 1) == ']' && + !net_IsValidIPv6Addr( + Substring(serverinfo + *hostnamePos + 1, *hostnameLen - 2))) + return NS_ERROR_MALFORMED_URI; + + return NS_OK; +} + +void nsAuthURLParser::ParseAfterScheme(const char* spec, int32_t specLen, + uint32_t* authPos, int32_t* authLen, + uint32_t* pathPos, int32_t* pathLen) { + MOZ_ASSERT(specLen >= 0, "unexpected"); + + uint32_t nslash = CountConsecutiveSlashes(spec, specLen); + + // search for the end of the authority section + const char* end = spec + specLen; + const char* p; + for (p = spec + nslash; p < end; ++p) { + if (*p == '/' || *p == '?' || *p == '#') break; + } + if (p < end) { + // spec = [/]<auth><path> + SET_RESULT(auth, nslash, p - (spec + nslash)); + SET_RESULT(path, p - spec, specLen - (p - spec)); + } else { + // spec = [/]<auth> + SET_RESULT(auth, nslash, specLen - nslash); + SET_RESULT(path, 0, -1); + } +} + +//---------------------------------------------------------------------------- +// nsStdURLParser implementation +//---------------------------------------------------------------------------- + +void nsStdURLParser::ParseAfterScheme(const char* spec, int32_t specLen, + uint32_t* authPos, int32_t* authLen, + uint32_t* pathPos, int32_t* pathLen) { + MOZ_ASSERT(specLen >= 0, "unexpected"); + + uint32_t nslash = CountConsecutiveSlashes(spec, specLen); + + // search for the end of the authority section + const char* end = spec + specLen; + const char* p; + for (p = spec + nslash; p < end; ++p) { + if (strchr("/?#;", *p)) break; + } + switch (nslash) { + case 0: + case 2: + if (p < end) { + // spec = (//)<auth><path> + SET_RESULT(auth, nslash, p - (spec + nslash)); + SET_RESULT(path, p - spec, specLen - (p - spec)); + } else { + // spec = (//)<auth> + SET_RESULT(auth, nslash, specLen - nslash); + SET_RESULT(path, 0, -1); + } + break; + case 1: + // spec = /<path> + SET_RESULT(auth, 0, -1); + SET_RESULT(path, 0, specLen); + break; + default: + // spec = ///[/]<path> + SET_RESULT(auth, 2, 0); + SET_RESULT(path, 2, specLen - 2); + } +} diff --git a/netwerk/base/nsURLParsers.h b/netwerk/base/nsURLParsers.h new file mode 100644 index 0000000000..3143022b90 --- /dev/null +++ b/netwerk/base/nsURLParsers.h @@ -0,0 +1,119 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef nsURLParsers_h__ +#define nsURLParsers_h__ + +#include "nsIURLParser.h" +#include "mozilla/Attributes.h" + +//---------------------------------------------------------------------------- +// base class for url parsers +//---------------------------------------------------------------------------- + +class nsBaseURLParser : public nsIURLParser { + public: + NS_DECL_NSIURLPARSER + + nsBaseURLParser() = default; + + protected: + // implemented by subclasses + virtual void ParseAfterScheme(const char* spec, int32_t specLen, + uint32_t* authPos, int32_t* authLen, + uint32_t* pathPos, int32_t* pathLen) = 0; +}; + +//---------------------------------------------------------------------------- +// an url parser for urls that do not have an authority section +// +// eg. file:foo/bar.txt +// file:/foo/bar.txt (treated equivalently) +// file:///foo/bar.txt +// +// eg. file:////foo/bar.txt (UNC-filepath = \\foo\bar.txt) +// +// XXX except in this case: +// file://foo/bar.txt (the authority "foo" is ignored) +//---------------------------------------------------------------------------- + +class nsNoAuthURLParser final : public nsBaseURLParser { + ~nsNoAuthURLParser() = default; + + public: + NS_DECL_THREADSAFE_ISUPPORTS + +#if defined(XP_WIN) + NS_IMETHOD ParseFilePath(const char*, int32_t, uint32_t*, int32_t*, uint32_t*, + int32_t*, uint32_t*, int32_t*) override; +#endif + + NS_IMETHOD ParseAuthority(const char* auth, int32_t authLen, + uint32_t* usernamePos, int32_t* usernameLen, + uint32_t* passwordPos, int32_t* passwordLen, + uint32_t* hostnamePos, int32_t* hostnameLen, + int32_t* port) override; + + void ParseAfterScheme(const char* spec, int32_t specLen, uint32_t* authPos, + int32_t* authLen, uint32_t* pathPos, + int32_t* pathLen) override; +}; + +//---------------------------------------------------------------------------- +// an url parser for urls that must have an authority section +// +// eg. http:www.foo.com/bar.html +// http:/www.foo.com/bar.html +// http://www.foo.com/bar.html (treated equivalently) +// http:///www.foo.com/bar.html +//---------------------------------------------------------------------------- + +class nsAuthURLParser : public nsBaseURLParser { + protected: + virtual ~nsAuthURLParser() = default; + + public: + NS_DECL_THREADSAFE_ISUPPORTS + + NS_IMETHOD ParseAuthority(const char* auth, int32_t authLen, + uint32_t* usernamePos, int32_t* usernameLen, + uint32_t* passwordPos, int32_t* passwordLen, + uint32_t* hostnamePos, int32_t* hostnameLen, + int32_t* port) override; + + NS_IMETHOD ParseUserInfo(const char* userinfo, int32_t userinfoLen, + uint32_t* usernamePos, int32_t* usernameLen, + uint32_t* passwordPos, + int32_t* passwordLen) override; + + NS_IMETHOD ParseServerInfo(const char* serverinfo, int32_t serverinfoLen, + uint32_t* hostnamePos, int32_t* hostnameLen, + int32_t* port) override; + + void ParseAfterScheme(const char* spec, int32_t specLen, uint32_t* authPos, + int32_t* authLen, uint32_t* pathPos, + int32_t* pathLen) override; +}; + +//---------------------------------------------------------------------------- +// an url parser for urls that may or may not have an authority section +// +// eg. http:www.foo.com (www.foo.com is authority) +// http:www.foo.com/bar.html (www.foo.com is authority) +// http:/www.foo.com/bar.html (www.foo.com is part of file path) +// http://www.foo.com/bar.html (www.foo.com is authority) +// http:///www.foo.com/bar.html (www.foo.com is part of file path) +//---------------------------------------------------------------------------- + +class nsStdURLParser : public nsAuthURLParser { + virtual ~nsStdURLParser() = default; + + public: + void ParseAfterScheme(const char* spec, int32_t specLen, uint32_t* authPos, + int32_t* authLen, uint32_t* pathPos, + int32_t* pathLen) override; +}; + +#endif // nsURLParsers_h__ diff --git a/netwerk/base/rust-helper/Cargo.toml b/netwerk/base/rust-helper/Cargo.toml new file mode 100644 index 0000000000..e522dae38b --- /dev/null +++ b/netwerk/base/rust-helper/Cargo.toml @@ -0,0 +1,9 @@ +[package] +name = "netwerk_helper" +version = "0.0.1" +authors = ["Jeff Hemphill <jthemphill@mozilla.com>"] + +[dependencies] +nserror = { path = "../../../xpcom/rust/nserror" } +nsstring = { path = "../../../xpcom/rust/nsstring" } +thin-vec = { version = "0.2.1", features = ["gecko-ffi"] }
\ No newline at end of file diff --git a/netwerk/base/rust-helper/cbindgen.toml b/netwerk/base/rust-helper/cbindgen.toml new file mode 100644 index 0000000000..1e5e235576 --- /dev/null +++ b/netwerk/base/rust-helper/cbindgen.toml @@ -0,0 +1,18 @@ +header = """/* 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/. */""" +autogen_warning = """/* DO NOT MODIFY THIS MANUALLY! This file was generated using cbindgen. */""" +include_guard = "mozilla_net_rustHelper_h" +include_version = true +braces = "SameLine" +line_length = 100 +tab_width = 2 +language = "C++" +namespaces = ["mozilla", "net"] +includes = ["nsError.h", "nsString.h"] + +[export] +item_types = ["globals", "enums", "structs", "unions", "typedefs", "opaque", "functions", "constants"] + +[export.rename] +"ThinVec" = "nsTArray" diff --git a/netwerk/base/rust-helper/moz.build b/netwerk/base/rust-helper/moz.build new file mode 100644 index 0000000000..1f7512ecf9 --- /dev/null +++ b/netwerk/base/rust-helper/moz.build @@ -0,0 +1,12 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +if CONFIG["COMPILE_ENVIRONMENT"]: + CbindgenHeader("rust_helper.h", inputs=["/netwerk/base/rust-helper"]) + + EXPORTS.mozilla.net += [ + "!rust_helper.h", + ] diff --git a/netwerk/base/rust-helper/src/lib.rs b/netwerk/base/rust-helper/src/lib.rs new file mode 100644 index 0000000000..df6e4af1e4 --- /dev/null +++ b/netwerk/base/rust-helper/src/lib.rs @@ -0,0 +1,360 @@ +/* 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/. */ + +extern crate nserror; +use self::nserror::*; + +extern crate nsstring; +use self::nsstring::{nsACString, nsCString}; + +extern crate thin_vec; +use self::thin_vec::ThinVec; + +use std::fs::File; +use std::io::{self, BufRead}; +use std::net::Ipv4Addr; + +/// HTTP leading whitespace, defined in netwerk/protocol/http/nsHttp.h +static HTTP_LWS: &'static [u8] = &[' ' as u8, '\t' as u8]; + +/// Trim leading whitespace, trailing whitespace, and quality-value +/// from a token. +fn trim_token(token: &[u8]) -> &[u8] { + // Trim left whitespace + let ltrim = token + .iter() + .take_while(|c| HTTP_LWS.iter().any(|ws| &ws == c)) + .count(); + + // Trim right whitespace + // remove "; q=..." if present + let rtrim = token[ltrim..] + .iter() + .take_while(|c| **c != (';' as u8) && HTTP_LWS.iter().all(|ws| ws != *c)) + .count(); + + &token[ltrim..ltrim + rtrim] +} + +#[no_mangle] +/// Allocates an nsACString that contains a ISO 639 language list +/// notated with HTTP "q" values for output with an HTTP Accept-Language +/// header. Previous q values will be stripped because the order of +/// the langs implies the q value. The q values are calculated by dividing +/// 1.0 amongst the number of languages present. +/// +/// Ex: passing: "en, ja" +/// returns: "en,ja;q=0.5" +/// +/// passing: "en, ja, fr_CA" +/// returns: "en,ja;q=0.7,fr_CA;q=0.3" +pub extern "C" fn rust_prepare_accept_languages<'a, 'b>( + i_accept_languages: &'a nsACString, + o_accept_languages: &'b mut nsACString, +) -> nsresult { + if i_accept_languages.is_empty() { + return NS_OK; + } + + let make_tokens = || { + i_accept_languages + .split(|c| *c == (',' as u8)) + .map(|token| trim_token(token)) + .filter(|token| token.len() != 0) + }; + + let n = make_tokens().count(); + + for (count_n, i_token) in make_tokens().enumerate() { + // delimiter if not first item + if count_n != 0 { + o_accept_languages.append(","); + } + + let token_pos = o_accept_languages.len(); + o_accept_languages.append(&i_token as &[u8]); + + { + let o_token = o_accept_languages.to_mut(); + canonicalize_language_tag(&mut o_token[token_pos..]); + } + + // Divide the quality-values evenly among the languages. + let q = 1.0 - count_n as f32 / n as f32; + + let u: u32 = ((q + 0.005) * 100.0) as u32; + // Only display q-value if less than 1.00. + if u < 100 { + // With a small number of languages, one decimal place is + // enough to prevent duplicate q-values. + // Also, trailing zeroes do not add any information, so + // they can be removed. + if n < 10 || u % 10 == 0 { + let u = (u + 5) / 10; + o_accept_languages.append(&format!(";q=0.{}", u)); + } else { + // Values below 10 require zero padding. + o_accept_languages.append(&format!(";q=0.{:02}", u)); + } + } + } + + NS_OK +} + +/// Defines a consistent capitalization for a given language string. +/// +/// # Arguments +/// * `token` - a narrow char slice describing a language. +/// +/// Valid language tags are of the form +/// "*", "fr", "en-US", "es-419", "az-Arab", "x-pig-latin", "man-Nkoo-GN" +/// +/// Language tags are defined in the +/// [rfc5646](https://tools.ietf.org/html/rfc5646) spec. According to +/// the spec: +/// +/// > At all times, language tags and their subtags, including private +/// > use and extensions, are to be treated as case insensitive: there +/// > exist conventions for the capitalization of some of the subtags, +/// > but these MUST NOT be taken to carry meaning. +/// +/// So why is this code even here? See bug 1108183, I guess. +fn canonicalize_language_tag(token: &mut [u8]) { + for c in token.iter_mut() { + *c = c.to_ascii_lowercase(); + } + + let sub_tags = token.split_mut(|c| *c == ('-' as u8)); + for (i, sub_tag) in sub_tags.enumerate() { + if i == 0 { + // ISO 639-1 language code, like the "en" in "en-US" + continue; + } + + match sub_tag.len() { + // Singleton tag, like "x" or "i". These signify a + // non-standard language, so we stop capitalizing after + // these. + 1 => break, + // ISO 3166-1 Country code, like "US" + 2 => { + sub_tag[0] = sub_tag[0].to_ascii_uppercase(); + sub_tag[1] = sub_tag[1].to_ascii_uppercase(); + } + // ISO 15924 script code, like "Nkoo" + 4 => { + sub_tag[0] = sub_tag[0].to_ascii_uppercase(); + } + _ => {} + }; + } +} + +#[no_mangle] +pub extern "C" fn rust_net_is_valid_ipv4_addr<'a>(addr: &'a nsACString) -> bool { + is_valid_ipv4_addr(addr) +} + +#[inline] +fn try_apply_digit(current_octet: u8, digit_to_apply: u8) -> Option<u8> { + current_octet.checked_mul(10)?.checked_add(digit_to_apply) +} + +pub fn is_valid_ipv4_addr<'a>(addr: &'a [u8]) -> bool { + let mut current_octet: Option<u8> = None; + let mut dots: u8 = 0; + for c in addr { + let c = *c as char; + match c { + '.' => { + match current_octet { + None => { + // starting an octet with a . is not allowed + return false; + } + Some(_) => { + dots = dots + 1; + current_octet = None; + } + } + } + // The character is not a digit + no_digit if no_digit.to_digit(10).is_none() => { + return false; + } + digit => { + match current_octet { + None => { + // Unwrap is sound because it has been checked in the previous arm + current_octet = Some(digit.to_digit(10).unwrap() as u8); + } + Some(octet) => { + if let Some(0) = current_octet { + // Leading 0 is not allowed + return false; + } + if let Some(applied) = + try_apply_digit(octet, digit.to_digit(10).unwrap() as u8) + { + current_octet = Some(applied); + } else { + // Multiplication or Addition overflowed + return false; + } + } + } + } + } + } + dots == 3 && current_octet.is_some() +} + +#[no_mangle] +pub extern "C" fn rust_net_is_valid_ipv6_addr<'a>(addr: &'a nsACString) -> bool { + is_valid_ipv6_addr(addr) +} + +#[inline(always)] +fn fast_is_hex_digit(c: u8) -> bool { + match c { + b'0'..=b'9' => true, + b'a'..=b'f' => true, + b'A'..=b'F' => true, + _ => false, + } +} + +pub fn is_valid_ipv6_addr<'a>(addr: &'a [u8]) -> bool { + let mut double_colon = false; + let mut colon_before = false; + let mut digits: u8 = 0; + let mut blocks: u8 = 0; + + // The smallest ipv6 is unspecified (::) + // The IP starts with a single colon + if addr.len() < 2 || addr[0] == b':' && addr[1] != b':' { + return false; + } + //Enumerate with an u8 for cache locality + for (i, c) in (0u8..).zip(addr) { + match c { + maybe_digit if fast_is_hex_digit(*maybe_digit) => { + // Too many digits in the block + if digits == 4 { + return false; + } + colon_before = false; + digits += 1; + } + b':' => { + // Too many columns + if double_colon && colon_before || blocks == 8 { + return false; + } + if !colon_before { + if digits != 0 { + blocks += 1; + } + digits = 0; + colon_before = true; + } else if !double_colon { + double_colon = true; + } + } + b'.' => { + // IPv4 from the last block + if is_valid_ipv4_addr(&addr[(i - digits) as usize..]) { + return double_colon && blocks < 6 || !double_colon && blocks == 6; + } + return false; + } + _ => { + // Invalid character + return false; + } + } + } + if colon_before && !double_colon { + // The IP ends with a single colon + return false; + } + if digits != 0 { + blocks += 1; + } + + double_colon && blocks < 8 || !double_colon && blocks == 8 +} + +#[no_mangle] +pub extern "C" fn rust_net_is_valid_scheme_char(a_char: u8) -> bool { + is_valid_scheme_char(a_char) +} + +#[no_mangle] +pub extern "C" fn rust_net_is_valid_scheme<'a>(scheme: &'a nsACString) -> bool { + if scheme.is_empty() { + return false; + } + + // first char must be alpha + if !scheme[0].is_ascii_alphabetic() { + return false; + } + + scheme[1..] + .iter() + .all(|a_char| is_valid_scheme_char(*a_char)) +} + +fn is_valid_scheme_char(a_char: u8) -> bool { + a_char.is_ascii_alphanumeric() || a_char == b'+' || a_char == b'.' || a_char == b'-' +} + +pub type ParsingCallback = extern "C" fn(&ThinVec<nsCString>) -> bool; + +#[no_mangle] +pub extern "C" fn rust_parse_etc_hosts<'a>(path: &'a nsACString, callback: ParsingCallback) { + let file = match File::open(&*path.to_utf8()) { + Ok(file) => io::BufReader::new(file), + Err(..) => return, + }; + + let mut array = ThinVec::new(); + for line in file.lines() { + let line = match line { + Ok(l) => l, + Err(..) => break, + }; + + let mut iter = line.split('#').next().unwrap().split_whitespace(); + iter.next(); // skip the IP + + array.extend( + iter.filter(|host| { + // Make sure it's a valid domain + let invalid = [ + '\0', '\t', '\n', '\r', ' ', '#', '%', '/', ':', '?', '@', '[', '\\', ']', + ]; + host.parse::<Ipv4Addr>().is_err() && !host.contains(&invalid[..]) + }) + .map(nsCString::from), + ); + + // /etc/hosts files can be huge. To make sure we don't block shutdown + // for every 100 domains that we parse we call the callback passing the + // domains and see if we should keep parsing. + if array.len() > 100 { + let keep_going = callback(&array); + array.clear(); + if !keep_going { + break; + } + } + } + + if !array.is_empty() { + callback(&array); + } +} |