From 0ebf5bdf043a27fd3dfb7f92e0cb63d88954c44d Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 03:47:29 +0200 Subject: Adding upstream version 115.8.0esr. Signed-off-by: Daniel Baumann --- netwerk/protocol/gio/GIOChannelChild.cpp | 461 +++++++++++ netwerk/protocol/gio/GIOChannelChild.h | 111 +++ netwerk/protocol/gio/GIOChannelParent.cpp | 324 ++++++++ netwerk/protocol/gio/GIOChannelParent.h | 80 ++ netwerk/protocol/gio/PGIOChannel.ipdl | 51 ++ netwerk/protocol/gio/components.conf | 24 + netwerk/protocol/gio/moz.build | 42 + netwerk/protocol/gio/nsGIOProtocolHandler.cpp | 1043 +++++++++++++++++++++++++ netwerk/protocol/gio/nsGIOProtocolHandler.h | 38 + 9 files changed, 2174 insertions(+) create mode 100644 netwerk/protocol/gio/GIOChannelChild.cpp create mode 100644 netwerk/protocol/gio/GIOChannelChild.h create mode 100644 netwerk/protocol/gio/GIOChannelParent.cpp create mode 100644 netwerk/protocol/gio/GIOChannelParent.h create mode 100644 netwerk/protocol/gio/PGIOChannel.ipdl create mode 100644 netwerk/protocol/gio/components.conf create mode 100644 netwerk/protocol/gio/moz.build create mode 100644 netwerk/protocol/gio/nsGIOProtocolHandler.cpp create mode 100644 netwerk/protocol/gio/nsGIOProtocolHandler.h (limited to 'netwerk/protocol/gio') diff --git a/netwerk/protocol/gio/GIOChannelChild.cpp b/netwerk/protocol/gio/GIOChannelChild.cpp new file mode 100644 index 0000000000..75e519b2ce --- /dev/null +++ b/netwerk/protocol/gio/GIOChannelChild.cpp @@ -0,0 +1,461 @@ +/* -*- 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 "mozilla/net/NeckoChild.h" +#include "GIOChannelChild.h" +#include "nsGIOProtocolHandler.h" +#include "mozilla/dom/ContentChild.h" +#include "mozilla/dom/BrowserChild.h" +#include "nsContentUtils.h" +#include "nsIBrowserChild.h" +#include "nsStringStream.h" +#include "nsNetUtil.h" +#include "base/compiler_specific.h" +#include "mozilla/ipc/IPCStreamUtils.h" +#include "mozilla/ipc/URIUtils.h" +#include "SerializedLoadContext.h" +#include "mozilla/ipc/BackgroundUtils.h" +#include "nsIURIMutator.h" +#include "nsContentSecurityManager.h" +#include "SerializedLoadContext.h" +#include "mozilla/Logging.h" + +using mozilla::dom::ContentChild; + +namespace mozilla { +#undef LOG +#define LOG(args) MOZ_LOG(gGIOLog, mozilla::LogLevel::Debug, args) +namespace net { + +GIOChannelChild::GIOChannelChild(nsIURI* aUri) + : mEventQ(new ChannelEventQueue(static_cast(this))) { + SetURI(aUri); + // We could support thread retargeting, but as long as we're being driven by + // IPDL on the main thread it doesn't buy us anything. + DisallowThreadRetargeting(); +} + +void GIOChannelChild::AddIPDLReference() { + MOZ_ASSERT(!mIPCOpen, "Attempt to retain more than one IPDL reference"); + mIPCOpen = true; + AddRef(); +} + +void GIOChannelChild::ReleaseIPDLReference() { + MOZ_ASSERT(mIPCOpen, "Attempt to release nonexistent IPDL reference"); + mIPCOpen = false; + Release(); +} + +//----------------------------------------------------------------------------- +// GIOChannelChild::nsISupports +//----------------------------------------------------------------------------- + +NS_IMPL_ISUPPORTS_INHERITED(GIOChannelChild, nsBaseChannel, nsIChildChannel) + +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +GIOChannelChild::AsyncOpen(nsIStreamListener* aListener) { + nsCOMPtr listener = aListener; + nsresult rv = + nsContentSecurityManager::doContentSecurityCheck(this, listener); + NS_ENSURE_SUCCESS(rv, rv); + + LOG(("GIOChannelChild::AsyncOpen [this=%p]\n", this)); + + NS_ENSURE_TRUE((gNeckoChild), NS_ERROR_FAILURE); + NS_ENSURE_TRUE( + !static_cast(gNeckoChild->Manager())->IsShuttingDown(), + NS_ERROR_FAILURE); + NS_ENSURE_ARG_POINTER(listener); + NS_ENSURE_TRUE(!mIsPending, NS_ERROR_IN_PROGRESS); + NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_ALREADY_OPENED); + + // Port checked in parent, but duplicate here so we can return with error + // immediately, as we've done since before e10s. + rv = NS_CheckPortSafety(nsBaseChannel::URI()); // Need to disambiguate, + // because in the child ipdl, + // a typedef URI is defined... + if (NS_FAILED(rv)) { + return rv; + } + + mozilla::dom::BrowserChild* browserChild = nullptr; + nsCOMPtr iBrowserChild; + NS_QueryNotificationCallbacks(mCallbacks, mLoadGroup, + NS_GET_IID(nsIBrowserChild), + getter_AddRefs(iBrowserChild)); + GetCallback(iBrowserChild); + if (iBrowserChild) { + browserChild = + static_cast(iBrowserChild.get()); + } + + mListener = listener; + + // add ourselves to the load group. + if (mLoadGroup) { + mLoadGroup->AddRequest(this, nullptr); + } + + Maybe ipcStream; + mozilla::ipc::SerializeIPCStream(do_AddRef(mUploadStream), ipcStream, + /* aAllowLazy */ false); + + uint32_t loadFlags = 0; + GetLoadFlags(&loadFlags); + + GIOChannelOpenArgs openArgs; + SerializeURI(nsBaseChannel::URI(), openArgs.uri()); + openArgs.startPos() = mStartPos; + openArgs.entityID() = mEntityID; + openArgs.uploadStream() = ipcStream; + openArgs.loadFlags() = loadFlags; + + nsCOMPtr loadInfo = LoadInfo(); + rv = mozilla::ipc::LoadInfoToLoadInfoArgs(loadInfo, &openArgs.loadInfo()); + NS_ENSURE_SUCCESS(rv, rv); + + // This must happen before the constructor message is sent. + SetupNeckoTarget(); + + gNeckoChild->SendPGIOChannelConstructor( + this, browserChild, IPC::SerializedLoadContext(this), openArgs); + + // The socket transport layer in the chrome process now has a logical ref to + // us until OnStopRequest is called. + AddIPDLReference(); + + mIsPending = true; + mWasOpened = true; + + return rv; +} + +NS_IMETHODIMP +GIOChannelChild::IsPending(bool* aResult) { + *aResult = mIsPending; + return NS_OK; +} + +nsresult GIOChannelChild::OpenContentStream(bool aAsync, + nsIInputStream** aStream, + nsIChannel** aChannel) { + MOZ_CRASH("GIOChannel*Child* should never have OpenContentStream called!"); + return NS_OK; +} + +mozilla::ipc::IPCResult GIOChannelChild::RecvOnStartRequest( + const nsresult& aChannelStatus, const int64_t& aContentLength, + const nsACString& aContentType, const nsACString& aEntityID, + const URIParams& aURI) { + LOG(("GIOChannelChild::RecvOnStartRequest [this=%p]\n", this)); + mEventQ->RunOrEnqueue(new NeckoTargetChannelFunctionEvent( + this, [self = UnsafePtr(this), aChannelStatus, + aContentLength, aContentType = nsCString(aContentType), + aEntityID = nsCString(aEntityID), aURI]() { + self->DoOnStartRequest(aChannelStatus, aContentLength, aContentType, + aEntityID, aURI); + })); + return IPC_OK(); +} + +void GIOChannelChild::DoOnStartRequest(const nsresult& aChannelStatus, + const int64_t& aContentLength, + const nsACString& aContentType, + const nsACString& aEntityID, + const URIParams& aURI) { + LOG(("GIOChannelChild::DoOnStartRequest [this=%p]\n", this)); + if (!mCanceled && NS_SUCCEEDED(mStatus)) { + mStatus = aChannelStatus; + } + + mContentLength = aContentLength; + SetContentType(aContentType); + mEntityID = aEntityID; + + nsCString spec; + nsCOMPtr uri = DeserializeURI(aURI); + nsresult rv = uri->GetSpec(spec); + if (NS_SUCCEEDED(rv)) { + // Changes nsBaseChannel::URI() + rv = NS_MutateURI(mURI).SetSpec(spec).Finalize(mURI); + } + + if (NS_FAILED(rv)) { + Cancel(rv); + } + + AutoEventEnqueuer ensureSerialDispatch(mEventQ); + rv = mListener->OnStartRequest(this); + if (NS_FAILED(rv)) { + Cancel(rv); + } +} + +mozilla::ipc::IPCResult GIOChannelChild::RecvOnDataAvailable( + const nsresult& aChannelStatus, const nsACString& aData, + const uint64_t& aOffset, const uint32_t& aCount) { + LOG(("GIOChannelChild::RecvOnDataAvailable [this=%p]\n", this)); + mEventQ->RunOrEnqueue(new NeckoTargetChannelFunctionEvent( + this, [self = UnsafePtr(this), aChannelStatus, + aData = nsCString(aData), aOffset, aCount]() { + self->DoOnDataAvailable(aChannelStatus, aData, aOffset, aCount); + })); + + return IPC_OK(); +} + +void GIOChannelChild::DoOnDataAvailable(const nsresult& aChannelStatus, + const nsACString& aData, + const uint64_t& aOffset, + const uint32_t& aCount) { + LOG(("GIOChannelChild::DoOnDataAvailable [this=%p]\n", this)); + + if (!mCanceled && NS_SUCCEEDED(mStatus)) { + mStatus = aChannelStatus; + } + + if (mCanceled) { + return; + } + + // NOTE: the OnDataAvailable contract requires the client to read all the data + // in the inputstream. This code relies on that ('data' will go away after + // this function). Apparently the previous, non-e10s behavior was to actually + // support only reading part of the data, allowing later calls to read the + // rest. + nsCOMPtr stringStream; + nsresult rv = + NS_NewByteInputStream(getter_AddRefs(stringStream), + Span(aData).To(aCount), NS_ASSIGNMENT_DEPEND); + if (NS_FAILED(rv)) { + Cancel(rv); + return; + } + + AutoEventEnqueuer ensureSerialDispatch(mEventQ); + rv = mListener->OnDataAvailable(this, stringStream, aOffset, aCount); + if (NS_FAILED(rv)) { + Cancel(rv); + } + stringStream->Close(); +} + +mozilla::ipc::IPCResult GIOChannelChild::RecvOnStopRequest( + const nsresult& aChannelStatus) { + LOG(("GIOChannelChild::RecvOnStopRequest [this=%p status=%" PRIx32 "]\n", + this, static_cast(aChannelStatus))); + + mEventQ->RunOrEnqueue(new NeckoTargetChannelFunctionEvent( + this, [self = UnsafePtr(this), aChannelStatus]() { + self->DoOnStopRequest(aChannelStatus); + })); + return IPC_OK(); +} + +void GIOChannelChild::DoOnStopRequest(const nsresult& aChannelStatus) { + LOG(("GIOChannelChild::DoOnStopRequest [this=%p status=%" PRIx32 "]\n", this, + static_cast(aChannelStatus))); + + if (!mCanceled) { + mStatus = aChannelStatus; + } + + { // Ensure that all queued ipdl events are dispatched before + // we initiate protocol deletion below. + mIsPending = false; + AutoEventEnqueuer ensureSerialDispatch(mEventQ); + (void)mListener->OnStopRequest(this, aChannelStatus); + + mListener = nullptr; + + if (mLoadGroup) { + mLoadGroup->RemoveRequest(this, nullptr, aChannelStatus); + } + } + + // This calls NeckoChild::DeallocPGIOChannelChild(), which deletes |this| if + // IPDL holds the last reference. Don't rely on |this| existing after here! + Send__delete__(this); +} + +mozilla::ipc::IPCResult GIOChannelChild::RecvFailedAsyncOpen( + const nsresult& aStatusCode) { + LOG(("GIOChannelChild::RecvFailedAsyncOpen [this=%p status=%" PRIx32 "]\n", + this, static_cast(aStatusCode))); + mEventQ->RunOrEnqueue(new NeckoTargetChannelFunctionEvent( + this, [self = UnsafePtr(this), aStatusCode]() { + self->DoFailedAsyncOpen(aStatusCode); + })); + return IPC_OK(); +} + +void GIOChannelChild::DoFailedAsyncOpen(const nsresult& aStatusCode) { + LOG(("GIOChannelChild::DoFailedAsyncOpen [this=%p status=%" PRIx32 "]\n", + this, static_cast(aStatusCode))); + mStatus = aStatusCode; + + if (mLoadGroup) { + mLoadGroup->RemoveRequest(this, nullptr, aStatusCode); + } + + if (mListener) { + mListener->OnStartRequest(this); + mIsPending = false; + mListener->OnStopRequest(this, aStatusCode); + } else { + mIsPending = false; + } + + mListener = nullptr; + + if (mIPCOpen) { + Send__delete__(this); + } +} + +mozilla::ipc::IPCResult GIOChannelChild::RecvDeleteSelf() { + mEventQ->RunOrEnqueue(new NeckoTargetChannelFunctionEvent( + this, + [self = UnsafePtr(this)]() { self->DoDeleteSelf(); })); + return IPC_OK(); +} + +void GIOChannelChild::DoDeleteSelf() { + if (mIPCOpen) { + Send__delete__(this); + } +} + +//----------------------------------------------------------------------------- +// GIOChannelChild::nsIResumableChannel +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +GIOChannelChild::Cancel(nsresult aStatus) { + LOG(("GIOChannelChild::Cancel [this=%p]\n", this)); + + if (mCanceled) { + return NS_OK; + } + + mCanceled = true; + mStatus = aStatus; + if (mIPCOpen) { + SendCancel(aStatus); + } + return NS_OK; +} + +NS_IMETHODIMP +GIOChannelChild::Suspend() { + NS_ENSURE_TRUE(mIPCOpen, NS_ERROR_NOT_AVAILABLE); + + LOG(("GIOChannelChild::Suspend [this=%p]\n", this)); + + // SendSuspend only once, when suspend goes from 0 to 1. + if (!mSuspendCount++) { + SendSuspend(); + mSuspendSent = true; + } + mEventQ->Suspend(); + + return NS_OK; +} + +NS_IMETHODIMP +GIOChannelChild::Resume() { + NS_ENSURE_TRUE(mIPCOpen, NS_ERROR_NOT_AVAILABLE); + + LOG(("GIOChannelChild::Resume [this=%p]\n", this)); + + // SendResume only once, when suspend count drops to 0. + if (!--mSuspendCount && mSuspendSent) { + SendResume(); + } + mEventQ->Resume(); + + return NS_OK; +} + +//----------------------------------------------------------------------------- +// GIOChannelChild::nsIChildChannel +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +GIOChannelChild::ConnectParent(uint32_t aId) { + NS_ENSURE_TRUE((gNeckoChild), NS_ERROR_FAILURE); + NS_ENSURE_TRUE( + !static_cast(gNeckoChild->Manager())->IsShuttingDown(), + NS_ERROR_FAILURE); + + LOG(("GIOChannelChild::ConnectParent [this=%p]\n", this)); + + mozilla::dom::BrowserChild* browserChild = nullptr; + nsCOMPtr iBrowserChild; + NS_QueryNotificationCallbacks(mCallbacks, mLoadGroup, + NS_GET_IID(nsIBrowserChild), + getter_AddRefs(iBrowserChild)); + GetCallback(iBrowserChild); + if (iBrowserChild) { + browserChild = + static_cast(iBrowserChild.get()); + } + + // This must happen before the constructor message is sent. + SetupNeckoTarget(); + + // The socket transport in the chrome process now holds a logical ref to us + // until OnStopRequest, or we do a redirect, or we hit an IPDL error. + AddIPDLReference(); + + GIOChannelConnectArgs connectArgs(aId); + + if (!gNeckoChild->SendPGIOChannelConstructor( + this, browserChild, IPC::SerializedLoadContext(this), connectArgs)) { + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +NS_IMETHODIMP +GIOChannelChild::CompleteRedirectSetup(nsIStreamListener* aListener) { + LOG(("GIOChannelChild::CompleteRedirectSetup [this=%p]\n", this)); + NS_ENSURE_TRUE(!mIsPending, NS_ERROR_IN_PROGRESS); + NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_ALREADY_OPENED); + + mIsPending = true; + mWasOpened = true; + mListener = aListener; + + // add ourselves to the load group. + if (mLoadGroup) { + mLoadGroup->AddRequest(this, nullptr); + } + + // We already have an open IPDL connection to the parent. If on-modify-request + // listeners or load group observers canceled us, let the parent handle it + // and send it back to us naturally. + return NS_OK; +} + +void GIOChannelChild::SetupNeckoTarget() { + if (mNeckoTarget) { + return; + } + nsCOMPtr loadInfo = LoadInfo(); + mNeckoTarget = + nsContentUtils::GetEventTargetByLoadInfo(loadInfo, TaskCategory::Network); + if (!mNeckoTarget) { + return; + } +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/protocol/gio/GIOChannelChild.h b/netwerk/protocol/gio/GIOChannelChild.h new file mode 100644 index 0000000000..158ab6804f --- /dev/null +++ b/netwerk/protocol/gio/GIOChannelChild.h @@ -0,0 +1,111 @@ +/* -*- 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_GIOCHANNELCHILD_H +#define NS_GIOCHANNELCHILD_H + +#include "mozilla/net/PGIOChannelChild.h" +#include "mozilla/net/ChannelEventQueue.h" +#include "nsBaseChannel.h" +#include "nsIUploadChannel.h" +#include "nsIProxiedChannel.h" +#include "nsIResumableChannel.h" +#include "nsIChildChannel.h" +#include "nsIEventTarget.h" +#include "nsIStreamListener.h" + +class nsIEventTarget; + +namespace mozilla { +namespace net { + +class GIOChannelChild final : public PGIOChannelChild, + public nsBaseChannel, + public nsIChildChannel { + public: + using nsIStreamListener = ::nsIStreamListener; + + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_NSICHILDCHANNEL + + NS_IMETHOD Cancel(nsresult aStatus) override; + NS_IMETHOD Suspend() override; + NS_IMETHOD Resume() override; + + explicit GIOChannelChild(nsIURI* uri); + + void AddIPDLReference(); + void ReleaseIPDLReference(); + + NS_IMETHOD AsyncOpen(nsIStreamListener* aListener) override; + + // Note that we handle this ourselves, overriding the nsBaseChannel + // default behavior, in order to be e10s-friendly. + NS_IMETHOD IsPending(bool* aResult) override; + + nsresult OpenContentStream(bool aAsync, nsIInputStream** aStream, + nsIChannel** aChannel) override; + + bool IsSuspended() const; + + protected: + virtual ~GIOChannelChild() = default; + + mozilla::ipc::IPCResult RecvOnStartRequest(const nsresult& aChannelStatus, + const int64_t& aContentLength, + const nsACString& aContentType, + const nsACString& aEntityID, + const URIParams& aURI) override; + mozilla::ipc::IPCResult RecvOnDataAvailable(const nsresult& aChannelStatus, + const nsACString& aData, + const uint64_t& aOffset, + const uint32_t& aCount) override; + mozilla::ipc::IPCResult RecvOnStopRequest( + const nsresult& aChannelStatus) override; + mozilla::ipc::IPCResult RecvFailedAsyncOpen( + const nsresult& aStatusCode) override; + mozilla::ipc::IPCResult RecvDeleteSelf() override; + + void DoOnStartRequest(const nsresult& aChannelStatus, + const int64_t& aContentLength, + const nsACString& aContentType, + const nsACString& aEntityID, const URIParams& aURI); + void DoOnDataAvailable(const nsresult& aChannelStatus, + const nsACString& aData, const uint64_t& aOffset, + const uint32_t& aCount); + void DoOnStopRequest(const nsresult& aChannelStatus); + void DoFailedAsyncOpen(const nsresult& aStatusCode); + void DoDeleteSelf(); + + void SetupNeckoTarget() override; + + friend class NeckoTargetChannelFunctionEvent; + + private: + nsCOMPtr mUploadStream; + + bool mIPCOpen = false; + const RefPtr mEventQ; + + bool mCanceled = false; + uint32_t mSuspendCount = 0; + ; + bool mIsPending = false; + + uint64_t mStartPos = 0; + nsCString mEntityID; + + // Set if SendSuspend is called. Determines if SendResume is needed when + // diverting callbacks to parent. + bool mSuspendSent = false; +}; + +inline bool GIOChannelChild::IsSuspended() const { return mSuspendCount != 0; } + +} // namespace net +} // namespace mozilla + +#endif /* NS_GIOCHANNELCHILD_H */ diff --git a/netwerk/protocol/gio/GIOChannelParent.cpp b/netwerk/protocol/gio/GIOChannelParent.cpp new file mode 100644 index 0000000000..e6127dcd69 --- /dev/null +++ b/netwerk/protocol/gio/GIOChannelParent.cpp @@ -0,0 +1,324 @@ +/* -*- 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 "GIOChannelParent.h" +#include "nsGIOProtocolHandler.h" +#include "mozilla/Assertions.h" +#include "mozilla/dom/ContentParent.h" +#include "mozilla/dom/BrowserParent.h" +#include "mozilla/net/NeckoParent.h" +#include "nsNetUtil.h" +#include "nsIChannel.h" +#include "mozilla/net/NeckoChannelParams.h" +#include "nsIAuthPrompt.h" +#include "nsIAuthPromptProvider.h" +#include "nsISecureBrowserUI.h" +#include "nsQueryObject.h" +#include "mozilla/Logging.h" +#include "mozilla/net/ChannelEventQueue.h" +#include "mozilla/ipc/URIUtils.h" + +using namespace mozilla::dom; +using namespace mozilla::ipc; + +namespace mozilla { +#undef LOG +#define LOG(args) MOZ_LOG(gGIOLog, mozilla::LogLevel::Debug, args) +namespace net { + +GIOChannelParent::GIOChannelParent(dom::BrowserParent* aIframeEmbedding, + nsILoadContext* aLoadContext, + PBOverrideStatus aOverrideStatus) + : mLoadContext(aLoadContext), + mPBOverride(aOverrideStatus), + mBrowserParent(aIframeEmbedding) { + mEventQ = new ChannelEventQueue(static_cast(this)); +} + +void GIOChannelParent::ActorDestroy(ActorDestroyReason why) { + // We may still have refcount>0 if the channel hasn't called OnStopRequest + // yet, but we must not send any more msgs to child. + mIPCClosed = true; +} + +//----------------------------------------------------------------------------- +// GIOChannelParent::nsISupports +//----------------------------------------------------------------------------- +NS_IMPL_ISUPPORTS(GIOChannelParent, nsIStreamListener, nsIParentChannel, + nsIInterfaceRequestor, nsIRequestObserver) + +//----------------------------------------------------------------------------- +// GIOChannelParent methods +//----------------------------------------------------------------------------- + +bool GIOChannelParent::Init(const GIOChannelCreationArgs& aOpenArgs) { + switch (aOpenArgs.type()) { + case GIOChannelCreationArgs::TGIOChannelOpenArgs: { + const GIOChannelOpenArgs& a = aOpenArgs.get_GIOChannelOpenArgs(); + return DoAsyncOpen(a.uri(), a.startPos(), a.entityID(), a.uploadStream(), + a.loadInfo(), a.loadFlags()); + } + case GIOChannelCreationArgs::TGIOChannelConnectArgs: { + const GIOChannelConnectArgs& cArgs = + aOpenArgs.get_GIOChannelConnectArgs(); + return ConnectChannel(cArgs.channelId()); + } + default: + MOZ_ASSERT_UNREACHABLE("unknown open type"); + return false; + } +} + +bool GIOChannelParent::DoAsyncOpen(const URIParams& aURI, + const uint64_t& aStartPos, + const nsCString& aEntityID, + const Maybe& aUploadStream, + const Maybe& aLoadInfoArgs, + const uint32_t& aLoadFlags) { + nsresult rv; + + nsCOMPtr uri = DeserializeURI(aURI); + if (!uri) { + return false; + } + +#ifdef DEBUG + LOG(("GIOChannelParent DoAsyncOpen [this=%p uri=%s]\n", this, + uri->GetSpecOrDefault().get())); +#endif + + nsCOMPtr ios(do_GetIOService(&rv)); + if (NS_FAILED(rv)) { + return SendFailedAsyncOpen(rv); + } + + nsAutoCString remoteType; + rv = GetRemoteType(remoteType); + if (NS_FAILED(rv)) { + return SendFailedAsyncOpen(rv); + } + + nsCOMPtr loadInfo; + rv = mozilla::ipc::LoadInfoArgsToLoadInfo(aLoadInfoArgs, remoteType, + getter_AddRefs(loadInfo)); + if (NS_FAILED(rv)) { + return SendFailedAsyncOpen(rv); + } + + OriginAttributes attrs; + rv = loadInfo->GetOriginAttributes(&attrs); + if (NS_FAILED(rv)) { + return SendFailedAsyncOpen(rv); + } + + nsCOMPtr chan; + rv = NS_NewChannelInternal(getter_AddRefs(chan), uri, loadInfo, nullptr, + nullptr, nullptr, aLoadFlags, ios); + + if (NS_FAILED(rv)) { + return SendFailedAsyncOpen(rv); + } + + mChannel = chan; + + nsIChannel* gioChan = static_cast(mChannel.get()); + + rv = gioChan->AsyncOpen(this); + if (NS_FAILED(rv)) { + return SendFailedAsyncOpen(rv); + } + + return true; +} + +bool GIOChannelParent::ConnectChannel(const uint64_t& channelId) { + nsresult rv; + + LOG(("Looking for a registered channel [this=%p, id=%" PRIx64 "]", this, + channelId)); + + nsCOMPtr channel; + rv = NS_LinkRedirectChannels(channelId, this, getter_AddRefs(channel)); + if (NS_SUCCEEDED(rv)) { + mChannel = channel; + } + + LOG((" found channel %p, rv=%08" PRIx32, mChannel.get(), + static_cast(rv))); + + return true; +} + +mozilla::ipc::IPCResult GIOChannelParent::RecvCancel(const nsresult& status) { + if (mChannel) { + mChannel->Cancel(status); + } + + return IPC_OK(); +} + +mozilla::ipc::IPCResult GIOChannelParent::RecvSuspend() { + if (mChannel) { + mChannel->Suspend(); + } + return IPC_OK(); +} + +mozilla::ipc::IPCResult GIOChannelParent::RecvResume() { + if (mChannel) { + mChannel->Resume(); + } + return IPC_OK(); +} + +//----------------------------------------------------------------------------- +// GIOChannelParent::nsIRequestObserver +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +GIOChannelParent::OnStartRequest(nsIRequest* aRequest) { + LOG(("GIOChannelParent::OnStartRequest [this=%p]\n", this)); + nsCOMPtr chan = do_QueryInterface(aRequest); + MOZ_ASSERT(chan); + NS_ENSURE_TRUE(chan, NS_ERROR_UNEXPECTED); + + int64_t contentLength; + chan->GetContentLength(&contentLength); + nsCString contentType; + chan->GetContentType(contentType); + nsresult channelStatus = NS_OK; + chan->GetStatus(&channelStatus); + + nsCString entityID; + URIParams uriparam; + nsCOMPtr uri; + chan->GetURI(getter_AddRefs(uri)); + SerializeURI(uri, uriparam); + + if (mIPCClosed || !SendOnStartRequest(channelStatus, contentLength, + contentType, entityID, uriparam)) { + return NS_ERROR_UNEXPECTED; + } + + return NS_OK; +} + +NS_IMETHODIMP +GIOChannelParent::OnStopRequest(nsIRequest* aRequest, nsresult aStatusCode) { + LOG(("GIOChannelParent::OnStopRequest: [this=%p status=%" PRIu32 "]\n", this, + static_cast(aStatusCode))); + + if (mIPCClosed || !SendOnStopRequest(aStatusCode)) { + return NS_ERROR_UNEXPECTED; + } + + return NS_OK; +} + +//----------------------------------------------------------------------------- +// GIOChannelParent::nsIStreamListener +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +GIOChannelParent::OnDataAvailable(nsIRequest* aRequest, + nsIInputStream* aInputStream, + uint64_t aOffset, uint32_t aCount) { + LOG(("GIOChannelParent::OnDataAvailable [this=%p]\n", this)); + + nsCString data; + nsresult rv = NS_ReadInputStreamToString(aInputStream, data, aCount); + if (NS_FAILED(rv)) { + return rv; + } + + nsresult channelStatus = NS_OK; + mChannel->GetStatus(&channelStatus); + + if (mIPCClosed || + !SendOnDataAvailable(channelStatus, data, aOffset, aCount)) { + return NS_ERROR_UNEXPECTED; + } + return NS_OK; +} + +//----------------------------------------------------------------------------- +// GIOChannelParent::nsIParentChannel +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +GIOChannelParent::SetParentListener(ParentChannelListener* aListener) { + // Do not need ptr to ParentChannelListener. + return NS_OK; +} + +NS_IMETHODIMP +GIOChannelParent::NotifyClassificationFlags(uint32_t aClassificationFlags, + bool aIsThirdParty) { + // Nothing to do. + return NS_OK; +} + +NS_IMETHODIMP +GIOChannelParent::SetClassifierMatchedInfo(const nsACString& aList, + const nsACString& aProvider, + const nsACString& aFullHash) { + // nothing to do + return NS_OK; +} + +NS_IMETHODIMP +GIOChannelParent::SetClassifierMatchedTrackingInfo( + const nsACString& aLists, const nsACString& aFullHashes) { + // nothing to do + return NS_OK; +} + +NS_IMETHODIMP +GIOChannelParent::Delete() { + if (mIPCClosed || !SendDeleteSelf()) { + return NS_ERROR_UNEXPECTED; + } + + return NS_OK; +} + +NS_IMETHODIMP +GIOChannelParent::GetRemoteType(nsACString& aRemoteType) { + if (!CanSend()) { + return NS_ERROR_UNEXPECTED; + } + + dom::PContentParent* pcp = Manager()->Manager(); + aRemoteType = static_cast(pcp)->GetRemoteType(); + return NS_OK; +} + +//----------------------------------------------------------------------------- +// GIOChannelParent::nsIInterfaceRequestor +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +GIOChannelParent::GetInterface(const nsIID& uuid, void** result) { + if (uuid.Equals(NS_GET_IID(nsIAuthPromptProvider)) || + uuid.Equals(NS_GET_IID(nsISecureBrowserUI))) { + if (mBrowserParent) { + return mBrowserParent->QueryInterface(uuid, result); + } + } + + // Only support nsILoadContext if child channel's callbacks did too + if (uuid.Equals(NS_GET_IID(nsILoadContext)) && mLoadContext) { + nsCOMPtr copy = mLoadContext; + copy.forget(result); + return NS_OK; + } + + return QueryInterface(uuid, result); +} + +//--------------------- +} // namespace net +} // namespace mozilla diff --git a/netwerk/protocol/gio/GIOChannelParent.h b/netwerk/protocol/gio/GIOChannelParent.h new file mode 100644 index 0000000000..21d41f0687 --- /dev/null +++ b/netwerk/protocol/gio/GIOChannelParent.h @@ -0,0 +1,80 @@ +/* -*- 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_GIOCHANNELPARENT_H +#define NS_GIOCHANNELPARENT_H + +#include "mozilla/net/PGIOChannelParent.h" +#include "mozilla/net/NeckoParent.h" +#include "nsIParentChannel.h" +#include "nsIInterfaceRequestor.h" + +class nsILoadContext; + +namespace mozilla { + +namespace dom { +class BrowserParent; +} // namespace dom + +namespace net { +class ChannelEventQueue; + +class GIOChannelParent final : public PGIOChannelParent, + public nsIParentChannel, + public nsIInterfaceRequestor { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIREQUESTOBSERVER + NS_DECL_NSISTREAMLISTENER + NS_DECL_NSIPARENTCHANNEL + NS_DECL_NSIINTERFACEREQUESTOR + + GIOChannelParent(dom::BrowserParent* aIframeEmbedding, + nsILoadContext* aLoadContext, + PBOverrideStatus aOverrideStatus); + + bool Init(const GIOChannelCreationArgs& aOpenArgs); + + protected: + virtual ~GIOChannelParent() = default; + + bool DoAsyncOpen(const URIParams& aURI, const uint64_t& aStartPos, + const nsCString& aEntityID, + const Maybe& aUploadStream, + const Maybe& aLoadInfoArgs, + const uint32_t& aLoadFlags); + + // used to connect redirected-to channel in parent with just created + // ChildChannel. Used during HTTP->FTP redirects. + bool ConnectChannel(const uint64_t& channelId); + + virtual mozilla::ipc::IPCResult RecvCancel(const nsresult& status) override; + virtual mozilla::ipc::IPCResult RecvSuspend() override; + virtual mozilla::ipc::IPCResult RecvResume() override; + + virtual void ActorDestroy(ActorDestroyReason why) override; + + nsCOMPtr mChannel; + + bool mIPCClosed = false; + + nsCOMPtr mLoadContext; + + PBOverrideStatus mPBOverride; + + // Set to the canceled status value if the main channel was canceled. + nsresult mStatus = NS_OK; + + RefPtr mBrowserParent; + + RefPtr mEventQ; +}; + +} // namespace net +} // namespace mozilla + +#endif /* NS_GIOCHANNELPARENT_H */ diff --git a/netwerk/protocol/gio/PGIOChannel.ipdl b/netwerk/protocol/gio/PGIOChannel.ipdl new file mode 100644 index 0000000000..e4f1f6380b --- /dev/null +++ b/netwerk/protocol/gio/PGIOChannel.ipdl @@ -0,0 +1,51 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set sw=2 ts=8 et tw=80 ft=cpp : */ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.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 protocol PNecko; +include URIParams; + +//FIXME: bug #792908 (NeckoChannelParams already included by PNecko) +include NeckoChannelParams; + +using PRTime from "prtime.h"; + +namespace mozilla { +namespace net { + +[ManualDealloc, ChildImpl=virtual, ParentImpl=virtual] +async protocol PGIOChannel +{ + manager PNecko; + +parent: + // Note: channels are opened during construction, so no open method here: + // see PNecko.ipdl + + async __delete__(); + + async Cancel(nsresult status); + async Suspend(); + async Resume(); + +child: + async OnStartRequest(nsresult aChannelStatus, + int64_t aContentLength, + nsCString aContentType, + nsCString aEntityID, + URIParams aURI); + async OnDataAvailable(nsresult channelStatus, + nsCString data, + uint64_t offset, + uint32_t count); + async OnStopRequest(nsresult channelStatus); + async FailedAsyncOpen(nsresult statusCode); + + async DeleteSelf(); +}; + +} // namespace net +} // namespace mozilla diff --git a/netwerk/protocol/gio/components.conf b/netwerk/protocol/gio/components.conf new file mode 100644 index 0000000000..a2bbfd8f19 --- /dev/null +++ b/netwerk/protocol/gio/components.conf @@ -0,0 +1,24 @@ +# -*- 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/. + +Classes = [ + { + 'cid': '{ee706783-3af8-4d19-9e84-e2ebfe213480}', + 'contract_ids': ['@mozilla.org/network/protocol;1?name=moz-gio'], + 'singleton': True, + 'type': 'nsGIOProtocolHandler', + 'headers': ['nsGIOProtocolHandler.h'], + 'constructor': 'nsGIOProtocolHandler::GetSingleton', + 'categories': { 'xpcom-startup': 'nsGIOProtocolHandler' }, + 'protocol_config': { + 'scheme': 'moz-gio', + 'flags': [ + 'URI_STD', + 'URI_DANGEROUS_TO_LOAD', + ], + }, + }, +] diff --git a/netwerk/protocol/gio/moz.build b/netwerk/protocol/gio/moz.build new file mode 100644 index 0000000000..4078e5605c --- /dev/null +++ b/netwerk/protocol/gio/moz.build @@ -0,0 +1,42 @@ +# -*- 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/. + +XPCOM_MANIFESTS += [ + "components.conf", +] + +EXPORTS += [ + "nsGIOProtocolHandler.h", +] + +EXPORTS.mozilla.net += [ + "GIOChannelChild.h", + "GIOChannelParent.h", +] + +UNIFIED_SOURCES += [ + "GIOChannelChild.cpp", + "GIOChannelParent.cpp", + "nsGIOProtocolHandler.cpp", +] + +IPDL_SOURCES = [ + "PGIOChannel.ipdl", +] + +include("/ipc/chromium/chromium-config.mozbuild") + +LOCAL_INCLUDES += [ + "/netwerk/base", +] + +FINAL_LIBRARY = "xul" + +if CONFIG["MOZ_WIDGET_TOOLKIT"] == "gtk": + CXXFLAGS += CONFIG["MOZ_GTK3_CFLAGS"] + +with Files("**"): + BUG_COMPONENT = ("Core", "Widget: Gtk") diff --git a/netwerk/protocol/gio/nsGIOProtocolHandler.cpp b/netwerk/protocol/gio/nsGIOProtocolHandler.cpp new file mode 100644 index 0000000000..51679f3f8c --- /dev/null +++ b/netwerk/protocol/gio/nsGIOProtocolHandler.cpp @@ -0,0 +1,1043 @@ +/* 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/. */ + +/* + * This code is based on original Mozilla gnome-vfs extension. It implements + * input stream provided by GVFS/GIO. + */ +#include "nsGIOProtocolHandler.h" +#include "GIOChannelChild.h" +#include "mozilla/Components.h" +#include "mozilla/ClearOnShutdown.h" +#include "mozilla/Logging.h" +#include "mozilla/net/NeckoChild.h" +#include "mozilla/NullPrincipal.h" +#include "nsIPrefBranch.h" +#include "nsIPrefService.h" +#include "nsIObserver.h" +#include "nsCRT.h" +#include "nsThreadUtils.h" +#include "nsProxyRelease.h" +#include "nsIStringBundle.h" +#include "nsMimeTypes.h" +#include "nsNetCID.h" +#include "nsNetUtil.h" +#include "nsServiceManagerUtils.h" +#include "nsIURI.h" +#include "nsIAuthPrompt.h" +#include "nsIChannel.h" +#include "nsIInputStream.h" +#include "nsIProtocolHandler.h" +#include "mozilla/Monitor.h" +#include "prtime.h" +#include +#include + +using namespace mozilla; + +#define MOZ_GIO_SCHEME "moz-gio" +#define MOZ_GIO_SUPPORTED_PROTOCOLS "network.gio.supported-protocols" + +//----------------------------------------------------------------------------- + +// NSPR_LOG_MODULES=gio:5 +LazyLogModule gGIOLog("gio"); +#undef LOG +#define LOG(args) MOZ_LOG(gGIOLog, mozilla::LogLevel::Debug, args) + +//----------------------------------------------------------------------------- +static nsresult MapGIOResult(gint code) { + switch (code) { + case G_IO_ERROR_NOT_FOUND: + return NS_ERROR_FILE_NOT_FOUND; // shows error + case G_IO_ERROR_INVALID_ARGUMENT: + return NS_ERROR_INVALID_ARG; + case G_IO_ERROR_NOT_SUPPORTED: + return NS_ERROR_NOT_AVAILABLE; + case G_IO_ERROR_NO_SPACE: + return NS_ERROR_FILE_NO_DEVICE_SPACE; + case G_IO_ERROR_READ_ONLY: + return NS_ERROR_FILE_READ_ONLY; + case G_IO_ERROR_PERMISSION_DENIED: + return NS_ERROR_FILE_ACCESS_DENIED; // wrong password/login + case G_IO_ERROR_CLOSED: + return NS_BASE_STREAM_CLOSED; // was EOF + case G_IO_ERROR_NOT_DIRECTORY: + return NS_ERROR_FILE_NOT_DIRECTORY; + case G_IO_ERROR_PENDING: + return NS_ERROR_IN_PROGRESS; + case G_IO_ERROR_EXISTS: + return NS_ERROR_FILE_ALREADY_EXISTS; + case G_IO_ERROR_IS_DIRECTORY: + return NS_ERROR_FILE_IS_DIRECTORY; + case G_IO_ERROR_NOT_MOUNTED: + return NS_ERROR_NOT_CONNECTED; // shows error + case G_IO_ERROR_HOST_NOT_FOUND: + return NS_ERROR_UNKNOWN_HOST; // shows error + case G_IO_ERROR_CANCELLED: + return NS_ERROR_ABORT; + case G_IO_ERROR_NOT_EMPTY: + return NS_ERROR_FILE_DIR_NOT_EMPTY; + case G_IO_ERROR_FILENAME_TOO_LONG: + return NS_ERROR_FILE_NAME_TOO_LONG; + case G_IO_ERROR_INVALID_FILENAME: + return NS_ERROR_FILE_INVALID_PATH; + case G_IO_ERROR_TIMED_OUT: + return NS_ERROR_NET_TIMEOUT; // shows error + case G_IO_ERROR_WOULD_BLOCK: + return NS_BASE_STREAM_WOULD_BLOCK; + case G_IO_ERROR_FAILED_HANDLED: + return NS_ERROR_ABORT; // Cancel on login dialog + + /* unhandled: + G_IO_ERROR_NOT_REGULAR_FILE, + G_IO_ERROR_NOT_SYMBOLIC_LINK, + G_IO_ERROR_NOT_MOUNTABLE_FILE, + G_IO_ERROR_TOO_MANY_LINKS, + G_IO_ERROR_ALREADY_MOUNTED, + G_IO_ERROR_CANT_CREATE_BACKUP, + G_IO_ERROR_WRONG_ETAG, + G_IO_ERROR_WOULD_RECURSE, + G_IO_ERROR_BUSY, + G_IO_ERROR_WOULD_MERGE, + G_IO_ERROR_TOO_MANY_OPEN_FILES + */ + // Make GCC happy + default: + return NS_ERROR_FAILURE; + } +} + +static nsresult MapGIOResult(GError* result) { + if (!result) { + return NS_OK; + } + return MapGIOResult(result->code); +} + +/** Return values for mount operation. + * These enums are used as mount operation return values. + */ +enum class MountOperationResult { + MOUNT_OPERATION_IN_PROGRESS, /** \enum operation in progress */ + MOUNT_OPERATION_SUCCESS, /** \enum operation successful */ + MOUNT_OPERATION_FAILED /** \enum operation not successful */ +}; + +//----------------------------------------------------------------------------- +/** + * Sort function compares according to file type (directory/file) + * and alphabethical order + * @param a pointer to GFileInfo object to compare + * @param b pointer to GFileInfo object to compare + * @return -1 when first object should be before the second, 0 when equal, + * +1 when second object should be before the first + */ +static gint FileInfoComparator(gconstpointer a, gconstpointer b) { + GFileInfo* ia = (GFileInfo*)a; + GFileInfo* ib = (GFileInfo*)b; + if (g_file_info_get_file_type(ia) == G_FILE_TYPE_DIRECTORY && + g_file_info_get_file_type(ib) != G_FILE_TYPE_DIRECTORY) { + return -1; + } + if (g_file_info_get_file_type(ib) == G_FILE_TYPE_DIRECTORY && + g_file_info_get_file_type(ia) != G_FILE_TYPE_DIRECTORY) { + return 1; + } + + return nsCRT::strcasecmp(g_file_info_get_name(ia), g_file_info_get_name(ib)); +} + +/* Declaration of mount callback functions */ +static void mount_enclosing_volume_finished(GObject* source_object, + GAsyncResult* res, + gpointer user_data); +static void mount_operation_ask_password( + GMountOperation* mount_op, const char* message, const char* default_user, + const char* default_domain, GAskPasswordFlags flags, gpointer user_data); +//----------------------------------------------------------------------------- +class nsGIOInputStream final : public nsIInputStream { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIINPUTSTREAM + + explicit nsGIOInputStream(const nsCString& uriSpec) : mSpec(uriSpec) {} + + void SetChannel(nsIChannel* channel) { + // We need to hold an owning reference to our channel. This is done + // so we can access the channel's notification callbacks to acquire + // a reference to a nsIAuthPrompt if we need to handle an interactive + // mount operation. + // + // However, the channel can only be accessed on the main thread, so + // we have to be very careful with ownership. Moreover, it doesn't + // support threadsafe addref/release, so proxying is the answer. + // + // Also, it's important to note that this likely creates a reference + // cycle since the channel likely owns this stream. This reference + // cycle is broken in our Close method. + + mChannel = do_AddRef(channel).take(); + } + void SetMountResult(MountOperationResult result, gint error_code); + + private: + ~nsGIOInputStream() { Close(); } + nsresult DoOpen(); + nsresult DoRead(char* aBuf, uint32_t aCount, uint32_t* aCountRead); + nsresult SetContentTypeOfChannel(const char* contentType); + nsresult MountVolume(); + nsresult DoOpenDirectory(); + nsresult DoOpenFile(GFileInfo* info); + nsCString mSpec; + nsIChannel* mChannel{nullptr}; // manually refcounted + GFile* mHandle{nullptr}; + GFileInputStream* mStream{nullptr}; + uint64_t mBytesRemaining{UINT64_MAX}; + nsresult mStatus{NS_OK}; + GList* mDirList{nullptr}; + GList* mDirListPtr{nullptr}; + nsCString mDirBuf; + uint32_t mDirBufCursor{0}; + bool mDirOpen{false}; + MountOperationResult mMountRes = + MountOperationResult::MOUNT_OPERATION_SUCCESS; + mozilla::Monitor mMonitorMountInProgress MOZ_UNANNOTATED{ + "GIOInputStream::MountFinished"}; + gint mMountErrorCode{}; +}; + +/** + * Set result of mount operation and notify monitor waiting for results. + * This method is called in main thread as long as it is used only + * in mount_enclosing_volume_finished function. + * @param result Result of mount operation + */ +void nsGIOInputStream::SetMountResult(MountOperationResult result, + gint error_code) { + mozilla::MonitorAutoLock mon(mMonitorMountInProgress); + mMountRes = result; + mMountErrorCode = error_code; + mon.Notify(); +} + +/** + * Start mount operation and wait in loop until it is finished. This method is + * called from thread which is trying to read from location. + */ +nsresult nsGIOInputStream::MountVolume() { + GMountOperation* mount_op = g_mount_operation_new(); + g_signal_connect(mount_op, "ask-password", + G_CALLBACK(mount_operation_ask_password), mChannel); + mMountRes = MountOperationResult::MOUNT_OPERATION_IN_PROGRESS; + /* g_file_mount_enclosing_volume uses a dbus request to mount the volume. + Callback mount_enclosing_volume_finished is called in main thread + (not this thread on which this method is called). */ + g_file_mount_enclosing_volume(mHandle, G_MOUNT_MOUNT_NONE, mount_op, nullptr, + mount_enclosing_volume_finished, this); + mozilla::MonitorAutoLock mon(mMonitorMountInProgress); + /* Waiting for finish of mount operation thread */ + while (mMountRes == MountOperationResult::MOUNT_OPERATION_IN_PROGRESS) { + mon.Wait(); + } + + g_object_unref(mount_op); + + if (mMountRes == MountOperationResult::MOUNT_OPERATION_FAILED) { + return MapGIOResult(mMountErrorCode); + } + return NS_OK; +} + +/** + * Create list of infos about objects in opened directory + * Return: NS_OK when list obtained, otherwise error code according + * to failed operation. + */ +nsresult nsGIOInputStream::DoOpenDirectory() { + GError* error = nullptr; + + GFileEnumerator* f_enum = g_file_enumerate_children( + mHandle, "standard::*,time::*", G_FILE_QUERY_INFO_NONE, nullptr, &error); + if (!f_enum) { + nsresult rv = MapGIOResult(error); + g_warning("Cannot read from directory: %s", error->message); + g_error_free(error); + return rv; + } + // fill list of file infos + GFileInfo* info = g_file_enumerator_next_file(f_enum, nullptr, &error); + while (info) { + mDirList = g_list_append(mDirList, info); + info = g_file_enumerator_next_file(f_enum, nullptr, &error); + } + g_object_unref(f_enum); + if (error) { + g_warning("Error reading directory content: %s", error->message); + nsresult rv = MapGIOResult(error); + g_error_free(error); + return rv; + } + mDirOpen = true; + + // Sort list of file infos by using FileInfoComparator function + mDirList = g_list_sort(mDirList, FileInfoComparator); + mDirListPtr = mDirList; + + // Write base URL (make sure it ends with a '/') + mDirBuf.AppendLiteral("300: "); + mDirBuf.Append(mSpec); + if (mSpec.get()[mSpec.Length() - 1] != '/') { + mDirBuf.Append('/'); + } + mDirBuf.Append('\n'); + + // Write column names + mDirBuf.AppendLiteral( + "200: filename content-length last-modified file-type\n"); + + // Write charset (assume UTF-8) + // XXX is this correct? + mDirBuf.AppendLiteral("301: UTF-8\n"); + SetContentTypeOfChannel(APPLICATION_HTTP_INDEX_FORMAT); + return NS_OK; +} + +/** + * Create file stream and set mime type for channel + * @param info file info used to determine mime type + * @return NS_OK when file stream created successfuly, error code otherwise + */ +nsresult nsGIOInputStream::DoOpenFile(GFileInfo* info) { + GError* error = nullptr; + + mStream = g_file_read(mHandle, nullptr, &error); + if (!mStream) { + nsresult rv = MapGIOResult(error); + g_warning("Cannot read from file: %s", error->message); + g_error_free(error); + return rv; + } + + const char* content_type = g_file_info_get_content_type(info); + if (content_type) { + char* mime_type = g_content_type_get_mime_type(content_type); + if (mime_type) { + if (strcmp(mime_type, APPLICATION_OCTET_STREAM) != 0) { + SetContentTypeOfChannel(mime_type); + } + g_free(mime_type); + } + } else { + g_warning("Missing content type."); + } + + mBytesRemaining = g_file_info_get_size(info); + // Update the content length attribute on the channel. We do this + // synchronously without proxying. This hack is not as bad as it looks! + mChannel->SetContentLength(mBytesRemaining); + + return NS_OK; +} + +/** + * Start file open operation, mount volume when needed and according to file + * type create file output stream or read directory content. + * @return NS_OK when file or directory opened successfully, error code + * otherwise + */ +nsresult nsGIOInputStream::DoOpen() { + nsresult rv; + GError* error = nullptr; + + NS_ASSERTION(mHandle == nullptr, "already open"); + + mHandle = g_file_new_for_uri(mSpec.get()); + + GFileInfo* info = g_file_query_info(mHandle, "standard::*", + G_FILE_QUERY_INFO_NONE, nullptr, &error); + + if (error) { + if (error->domain == G_IO_ERROR && error->code == G_IO_ERROR_NOT_MOUNTED) { + // location is not yet mounted, try to mount + g_error_free(error); + if (NS_IsMainThread()) { + return NS_ERROR_NOT_CONNECTED; + } + error = nullptr; + rv = MountVolume(); + if (rv != NS_OK) { + return rv; + } + // get info again + info = g_file_query_info(mHandle, "standard::*", G_FILE_QUERY_INFO_NONE, + nullptr, &error); + // second try to get file info from remote files after media mount + if (!info) { + g_warning("Unable to get file info: %s", error->message); + rv = MapGIOResult(error); + g_error_free(error); + return rv; + } + } else { + g_warning("Unable to get file info: %s", error->message); + rv = MapGIOResult(error); + g_error_free(error); + return rv; + } + } + // Get file type to handle directories and file differently + GFileType f_type = g_file_info_get_file_type(info); + if (f_type == G_FILE_TYPE_DIRECTORY) { + // directory + rv = DoOpenDirectory(); + } else if (f_type != G_FILE_TYPE_UNKNOWN) { + // file + rv = DoOpenFile(info); + } else { + g_warning("Unable to get file type."); + rv = NS_ERROR_FILE_NOT_FOUND; + } + if (info) { + g_object_unref(info); + } + return rv; +} + +/** + * Read content of file or create file list from directory + * @param aBuf read destination buffer + * @param aCount length of destination buffer + * @param aCountRead number of read characters + * @return NS_OK when read successfully, NS_BASE_STREAM_CLOSED when end of file, + * error code otherwise + */ +nsresult nsGIOInputStream::DoRead(char* aBuf, uint32_t aCount, + uint32_t* aCountRead) { + nsresult rv = NS_ERROR_NOT_AVAILABLE; + if (mStream) { + // file read + GError* error = nullptr; + uint32_t bytes_read = g_input_stream_read(G_INPUT_STREAM(mStream), aBuf, + aCount, nullptr, &error); + if (error) { + rv = MapGIOResult(error); + *aCountRead = 0; + g_warning("Cannot read from file: %s", error->message); + g_error_free(error); + return rv; + } + *aCountRead = bytes_read; + mBytesRemaining -= *aCountRead; + return NS_OK; + } + if (mDirOpen) { + // directory read + while (aCount && rv != NS_BASE_STREAM_CLOSED) { + // Copy data out of our buffer + uint32_t bufLen = mDirBuf.Length() - mDirBufCursor; + if (bufLen) { + uint32_t n = std::min(bufLen, aCount); + memcpy(aBuf, mDirBuf.get() + mDirBufCursor, n); + *aCountRead += n; + aBuf += n; + aCount -= n; + mDirBufCursor += n; + } + + if (!mDirListPtr) // Are we at the end of the directory list? + { + rv = NS_BASE_STREAM_CLOSED; + } else if (aCount) // Do we need more data? + { + GFileInfo* info = (GFileInfo*)mDirListPtr->data; + + // Prune '.' and '..' from directory listing. + const char* fname = g_file_info_get_name(info); + if (fname && fname[0] == '.' && + (fname[1] == '\0' || (fname[1] == '.' && fname[2] == '\0'))) { + mDirListPtr = mDirListPtr->next; + continue; + } + + mDirBuf.AssignLiteral("201: "); + + // The "filename" field + nsCString escName; + nsCOMPtr nu = do_GetService(NS_NETUTIL_CONTRACTID); + if (nu && fname) { + nu->EscapeString(nsDependentCString(fname), + nsINetUtil::ESCAPE_URL_PATH, escName); + + mDirBuf.Append(escName); + mDirBuf.Append(' '); + } + + // The "content-length" field + // XXX truncates size from 64-bit to 32-bit + mDirBuf.AppendInt(int32_t(g_file_info_get_size(info))); + mDirBuf.Append(' '); + + // The "last-modified" field + // + // NSPR promises: PRTime is compatible with time_t + // we just need to convert from seconds to microseconds + GTimeVal gtime; + g_file_info_get_modification_time(info, >ime); + + PRExplodedTime tm; + PRTime pt = ((PRTime)gtime.tv_sec) * 1000000; + PR_ExplodeTime(pt, PR_GMTParameters, &tm); + { + char buf[64]; + PR_FormatTimeUSEnglish(buf, sizeof(buf), + "%a,%%20%d%%20%b%%20%Y%%20%H:%M:%S%%20GMT ", + &tm); + mDirBuf.Append(buf); + } + + // The "file-type" field + switch (g_file_info_get_file_type(info)) { + case G_FILE_TYPE_REGULAR: + mDirBuf.AppendLiteral("FILE "); + break; + case G_FILE_TYPE_DIRECTORY: + mDirBuf.AppendLiteral("DIRECTORY "); + break; + case G_FILE_TYPE_SYMBOLIC_LINK: + mDirBuf.AppendLiteral("SYMBOLIC-LINK "); + break; + default: + break; + } + mDirBuf.Append('\n'); + + mDirBufCursor = 0; + mDirListPtr = mDirListPtr->next; + } + } + } + return rv; +} + +/** + * This class is used to implement SetContentTypeOfChannel. + */ +class nsGIOSetContentTypeEvent : public mozilla::Runnable { + public: + nsGIOSetContentTypeEvent(nsIChannel* channel, const char* contentType) + : mozilla::Runnable("nsGIOSetContentTypeEvent"), + mChannel(channel), + mContentType(contentType) { + // stash channel reference in mChannel. no AddRef here! see note + // in SetContentTypeOfchannel. + } + + NS_IMETHOD Run() override { + mChannel->SetContentType(mContentType); + return NS_OK; + } + + private: + nsIChannel* mChannel; + nsCString mContentType; +}; + +nsresult nsGIOInputStream::SetContentTypeOfChannel(const char* contentType) { + // We need to proxy this call over to the main thread. We post an + // asynchronous event in this case so that we don't delay reading data, and + // we know that this is safe to do since the channel's reference will be + // released asynchronously as well. We trust the ordering of the main + // thread's event queue to protect us against memory corruption. + + nsresult rv; + nsCOMPtr ev = + new nsGIOSetContentTypeEvent(mChannel, contentType); + if (!ev) { + rv = NS_ERROR_OUT_OF_MEMORY; + } else { + rv = NS_DispatchToMainThread(ev); + } + return rv; +} + +NS_IMPL_ISUPPORTS(nsGIOInputStream, nsIInputStream) + +/** + * Free all used memory and close stream. + */ +NS_IMETHODIMP +nsGIOInputStream::Close() { + if (mStream) { + g_object_unref(mStream); + mStream = nullptr; + } + + if (mHandle) { + g_object_unref(mHandle); + mHandle = nullptr; + } + + if (mDirList) { + // Destroy the list of GIOFileInfo objects... + g_list_foreach(mDirList, (GFunc)g_object_unref, nullptr); + g_list_free(mDirList); + mDirList = nullptr; + mDirListPtr = nullptr; + } + + if (mChannel) { + NS_ReleaseOnMainThread("nsGIOInputStream::mChannel", dont_AddRef(mChannel)); + + mChannel = nullptr; + } + + mSpec.Truncate(); // free memory + + // Prevent future reads from re-opening the handle. + if (NS_SUCCEEDED(mStatus)) { + mStatus = NS_BASE_STREAM_CLOSED; + } + + return NS_OK; +} + +/** + * Return number of remaining bytes available on input + * @param aResult remaining bytes + */ +NS_IMETHODIMP +nsGIOInputStream::Available(uint64_t* aResult) { + if (NS_FAILED(mStatus)) { + return mStatus; + } + + *aResult = mBytesRemaining; + + return NS_OK; +} + +/** + * Return the status of the input stream + */ +NS_IMETHODIMP +nsGIOInputStream::StreamStatus() { return mStatus; } + +/** + * Trying to read from stream. When location is not available it tries to mount + * it. + * @param aBuf buffer to put read data + * @param aCount length of aBuf + * @param aCountRead number of bytes actually read + */ +NS_IMETHODIMP +nsGIOInputStream::Read(char* aBuf, uint32_t aCount, uint32_t* aCountRead) { + *aCountRead = 0; + // Check if file is already opened, otherwise open it + if (!mStream && !mDirOpen && mStatus == NS_OK) { + mStatus = DoOpen(); + if (NS_FAILED(mStatus)) { + return mStatus; + } + } + + mStatus = DoRead(aBuf, aCount, aCountRead); + // Check if all data has been read + if (mStatus == NS_BASE_STREAM_CLOSED) { + return NS_OK; + } + + // Check whenever any error appears while reading + return mStatus; +} + +NS_IMETHODIMP +nsGIOInputStream::ReadSegments(nsWriteSegmentFun aWriter, void* aClosure, + uint32_t aCount, uint32_t* aResult) { + // There is no way to implement this using GnomeVFS, but fortunately + // that doesn't matter. Because we are a blocking input stream, Necko + // isn't going to call our ReadSegments method. + MOZ_ASSERT_UNREACHABLE("nsGIOInputStream::ReadSegments"); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsGIOInputStream::IsNonBlocking(bool* aResult) { + *aResult = false; + return NS_OK; +} + +//----------------------------------------------------------------------------- + +/** + * Called when finishing mount operation. Result of operation is set in + * nsGIOInputStream. This function is called in main thread as an async request + * typically from dbus. + * @param source_object GFile object which requested the mount + * @param res result object + * @param user_data pointer to nsGIOInputStream + */ +static void mount_enclosing_volume_finished(GObject* source_object, + GAsyncResult* res, + gpointer user_data) { + GError* error = nullptr; + + nsGIOInputStream* istream = static_cast(user_data); + + g_file_mount_enclosing_volume_finish(G_FILE(source_object), res, &error); + + if (error) { + g_warning("Mount failed: %s %d", error->message, error->code); + istream->SetMountResult(MountOperationResult::MOUNT_OPERATION_FAILED, + error->code); + g_error_free(error); + } else { + istream->SetMountResult(MountOperationResult::MOUNT_OPERATION_SUCCESS, 0); + } +} + +/** + * This function is called when username or password are requested from user. + * This function is called in main thread as async request from dbus. + * @param mount_op mount operation + * @param message message to show to user + * @param default_user preffered user + * @param default_domain domain name + * @param flags what type of information is required + * @param user_data nsIChannel + */ +static void mount_operation_ask_password( + GMountOperation* mount_op, const char* message, const char* default_user, + const char* default_domain, GAskPasswordFlags flags, gpointer user_data) { + nsIChannel* channel = (nsIChannel*)user_data; + if (!channel) { + g_mount_operation_reply(mount_op, G_MOUNT_OPERATION_ABORTED); + return; + } + // We can't handle request for domain + if (flags & G_ASK_PASSWORD_NEED_DOMAIN) { + g_mount_operation_reply(mount_op, G_MOUNT_OPERATION_ABORTED); + return; + } + + nsCOMPtr prompt; + NS_QueryNotificationCallbacks(channel, prompt); + + // If no auth prompt, then give up. We could failover to using the + // WindowWatcher service, but that might defeat a consumer's purposeful + // attempt to disable authentication (for whatever reason). + if (!prompt) { + g_mount_operation_reply(mount_op, G_MOUNT_OPERATION_ABORTED); + return; + } + // Parse out the host and port... + nsCOMPtr uri; + channel->GetURI(getter_AddRefs(uri)); + if (!uri) { + g_mount_operation_reply(mount_op, G_MOUNT_OPERATION_ABORTED); + return; + } + + nsAutoCString scheme, hostPort; + uri->GetScheme(scheme); + uri->GetHostPort(hostPort); + + // It doesn't make sense for either of these strings to be empty. What kind + // of funky URI is this? + if (scheme.IsEmpty() || hostPort.IsEmpty()) { + g_mount_operation_reply(mount_op, G_MOUNT_OPERATION_ABORTED); + return; + } + // Construct the single signon key. Altering the value of this key will + // cause people's remembered passwords to be forgotten. Think carefully + // before changing the way this key is constructed. + nsAutoString key, realm; + + NS_ConvertUTF8toUTF16 dispHost(scheme); + dispHost.AppendLiteral("://"); + dispHost.Append(NS_ConvertUTF8toUTF16(hostPort)); + + key = dispHost; + if (*default_domain != '\0') { + // We assume the realm string is ASCII. That might be a bogus assumption, + // but we have no idea what encoding GnomeVFS is using, so for now we'll + // limit ourselves to ISO-Latin-1. XXX What is a better solution? + realm.Append('"'); + realm.Append(NS_ConvertASCIItoUTF16(default_domain)); + realm.Append('"'); + key.Append(' '); + key.Append(realm); + } + // Construct the message string... + // + // We use Necko's string bundle here. This code really should be encapsulated + // behind some Necko API, after all this code is based closely on the code in + // nsHttpChannel.cpp. + nsCOMPtr bundleSvc = + do_GetService(NS_STRINGBUNDLE_CONTRACTID); + if (!bundleSvc) { + g_mount_operation_reply(mount_op, G_MOUNT_OPERATION_ABORTED); + return; + } + nsCOMPtr bundle; + bundleSvc->CreateBundle("chrome://global/locale/commonDialogs.properties", + getter_AddRefs(bundle)); + if (!bundle) { + g_mount_operation_reply(mount_op, G_MOUNT_OPERATION_ABORTED); + return; + } + nsAutoString nsmessage; + + if (flags & G_ASK_PASSWORD_NEED_PASSWORD) { + if (flags & G_ASK_PASSWORD_NEED_USERNAME) { + if (!realm.IsEmpty()) { + AutoTArray strings = {realm, dispHost}; + bundle->FormatStringFromName("EnterLoginForRealm3", strings, nsmessage); + } else { + AutoTArray strings = {dispHost}; + bundle->FormatStringFromName("EnterUserPasswordFor2", strings, + nsmessage); + } + } else { + NS_ConvertUTF8toUTF16 userName(default_user); + AutoTArray strings = {userName, dispHost}; + bundle->FormatStringFromName("EnterPasswordFor", strings, nsmessage); + } + } else { + g_warning("Unknown mount operation request (flags: %x)", flags); + } + + if (nsmessage.IsEmpty()) { + g_mount_operation_reply(mount_op, G_MOUNT_OPERATION_ABORTED); + return; + } + // Prompt the user... + nsresult rv; + bool retval = false; + char16_t *user = nullptr, *pass = nullptr; + if (default_user) { + // user will be freed by PromptUsernameAndPassword + user = ToNewUnicode(NS_ConvertUTF8toUTF16(default_user)); + } + if (flags & G_ASK_PASSWORD_NEED_USERNAME) { + rv = prompt->PromptUsernameAndPassword( + nullptr, nsmessage.get(), key.get(), + nsIAuthPrompt::SAVE_PASSWORD_PERMANENTLY, &user, &pass, &retval); + } else { + rv = prompt->PromptPassword(nullptr, nsmessage.get(), key.get(), + nsIAuthPrompt::SAVE_PASSWORD_PERMANENTLY, &pass, + &retval); + } + if (NS_FAILED(rv) || !retval) { // was || user == '\0' || pass == '\0' + g_mount_operation_reply(mount_op, G_MOUNT_OPERATION_ABORTED); + free(user); + free(pass); + return; + } + /* GIO should accept UTF8 */ + g_mount_operation_set_username(mount_op, NS_ConvertUTF16toUTF8(user).get()); + g_mount_operation_set_password(mount_op, NS_ConvertUTF16toUTF8(pass).get()); + free(user); + free(pass); + g_mount_operation_reply(mount_op, G_MOUNT_OPERATION_HANDLED); +} + +//----------------------------------------------------------------------------- + +mozilla::StaticRefPtr nsGIOProtocolHandler::sSingleton; + +already_AddRefed nsGIOProtocolHandler::GetSingleton() { + if (!sSingleton) { + sSingleton = new nsGIOProtocolHandler(); + sSingleton->Init(); + ClearOnShutdown(&sSingleton); + } + return do_AddRef(sSingleton); +} + +NS_IMPL_ISUPPORTS(nsGIOProtocolHandler, nsIProtocolHandler, nsIObserver) + +nsresult nsGIOProtocolHandler::Init() { + if (net::IsNeckoChild()) { + net::NeckoChild::InitNeckoChild(); + } + nsCOMPtr prefs = do_GetService(NS_PREFSERVICE_CONTRACTID); + if (prefs) { + InitSupportedProtocolsPref(prefs); + prefs->AddObserver(MOZ_GIO_SUPPORTED_PROTOCOLS, this, false); + } + + return NS_OK; +} + +void nsGIOProtocolHandler::InitSupportedProtocolsPref(nsIPrefBranch* prefs) { + nsCOMPtr ioService = components::IO::Service(); + if (NS_WARN_IF(!ioService)) { + LOG(("gio: ioservice not available\n")); + return; + } + + // Get user preferences to determine which protocol is supported. + // Gvfs/GIO has a set of supported protocols like obex, network, archive, + // computer, dav, cdda, gphoto2, trash, etc. Some of these seems to be + // irrelevant to process by browser. By default accept only sftp protocol so + // far. + nsAutoCString prefValue; + nsresult rv = prefs->GetCharPref(MOZ_GIO_SUPPORTED_PROTOCOLS, prefValue); + if (NS_SUCCEEDED(rv)) { + prefValue.StripWhitespace(); + ToLowerCase(prefValue); + } else { + prefValue.AssignLiteral( +#ifdef MOZ_PROXY_BYPASS_PROTECTION + "" // use none +#else + "sftp:" // use defaults (comma separated list) +#endif + ); + } + LOG(("gio: supported protocols \"%s\"\n", prefValue.get())); + + // Unregister any previously registered dynamic protocols. + for (const nsCString& scheme : mSupportedProtocols) { + LOG(("gio: unregistering handler for \"%s\"", scheme.get())); + ioService->UnregisterProtocolHandler(scheme); + } + mSupportedProtocols.Clear(); + + // Register each protocol from the pref branch to reference + // nsGIOProtocolHandler. + for (const nsDependentCSubstring& protocol : prefValue.Split(',')) { + if (NS_WARN_IF(!StringEndsWith(protocol, ":"_ns))) { + continue; // each protocol must end with a `:` character to be recognized + } + + nsCString scheme(Substring(protocol, 0, protocol.Length() - 1)); + if (NS_SUCCEEDED(ioService->RegisterProtocolHandler( + scheme, this, + nsIProtocolHandler::URI_STD | + nsIProtocolHandler::URI_DANGEROUS_TO_LOAD, + /* aDefaultPort */ -1))) { + LOG(("gio: successfully registered handler for \"%s\"", scheme.get())); + mSupportedProtocols.AppendElement(scheme); + } else { + LOG(("gio: failed to register handler for \"%s\"", scheme.get())); + } + } +} + +bool nsGIOProtocolHandler::IsSupportedProtocol(const nsCString& aScheme) { + for (const auto& protocol : mSupportedProtocols) { + if (aScheme.EqualsIgnoreCase(protocol)) { + return true; + } + } + return false; +} + +NS_IMETHODIMP +nsGIOProtocolHandler::GetScheme(nsACString& aScheme) { + aScheme.AssignLiteral(MOZ_GIO_SCHEME); + return NS_OK; +} + +static bool IsValidGIOScheme(const nsACString& aScheme) { + // Verify that GIO supports this URI scheme. + GVfs* gvfs = g_vfs_get_default(); + + if (!gvfs) { + g_warning("Cannot get GVfs object."); + return false; + } + + const gchar* const* uri_schemes = g_vfs_get_supported_uri_schemes(gvfs); + + while (*uri_schemes != nullptr) { + // While flatSpec ends with ':' the uri_scheme does not. Therefore do not + // compare last character. + if (aScheme.Equals(*uri_schemes)) { + return true; + } + uri_schemes++; + } + + return false; +} + +NS_IMETHODIMP +nsGIOProtocolHandler::NewChannel(nsIURI* aURI, nsILoadInfo* aLoadInfo, + nsIChannel** aResult) { + NS_ENSURE_ARG_POINTER(aURI); + nsresult rv; + + nsAutoCString spec; + rv = aURI->GetSpec(spec); + if (NS_FAILED(rv)) { + return rv; + } + + nsAutoCString scheme; + rv = aURI->GetScheme(scheme); + if (NS_FAILED(rv)) { + return rv; + } + + if (!IsSupportedProtocol(scheme)) { + return NS_ERROR_UNKNOWN_PROTOCOL; + } + + // g_vfs_get_supported_uri_schemes() returns a very limited list in the + // child due to the sandbox, so we only check if its valid for the parent. + if (XRE_IsParentProcess() && !IsValidGIOScheme(scheme)) { + return NS_ERROR_UNKNOWN_PROTOCOL; + } + + RefPtr channel; + if (net::IsNeckoChild()) { + channel = new mozilla::net::GIOChannelChild(aURI); + // set the loadInfo on the new channel + channel->SetLoadInfo(aLoadInfo); + + rv = channel->SetContentType(nsLiteralCString(UNKNOWN_CONTENT_TYPE)); + NS_ENSURE_SUCCESS(rv, rv); + + channel.forget(aResult); + return NS_OK; + } + + RefPtr stream = new nsGIOInputStream(spec); + if (!stream) { + return NS_ERROR_OUT_OF_MEMORY; + } + + RefPtr tmpStream = stream; + rv = NS_NewInputStreamChannelInternal(aResult, aURI, tmpStream.forget(), + nsLiteralCString(UNKNOWN_CONTENT_TYPE), + ""_ns, // aContentCharset + aLoadInfo); + if (NS_SUCCEEDED(rv)) { + stream->SetChannel(*aResult); + } + + return rv; +} + +NS_IMETHODIMP +nsGIOProtocolHandler::AllowPort(int32_t aPort, const char* aScheme, + bool* aResult) { + // Don't override anything. + *aResult = false; + return NS_OK; +} + +NS_IMETHODIMP +nsGIOProtocolHandler::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) { + if (strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID) == 0) { + nsCOMPtr prefs = do_QueryInterface(aSubject); + InitSupportedProtocolsPref(prefs); + } + return NS_OK; +} diff --git a/netwerk/protocol/gio/nsGIOProtocolHandler.h b/netwerk/protocol/gio/nsGIOProtocolHandler.h new file mode 100644 index 0000000000..08e7c01bed --- /dev/null +++ b/netwerk/protocol/gio/nsGIOProtocolHandler.h @@ -0,0 +1,38 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.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 nsGIOProtocolHandler_h___ +#define nsGIOProtocolHandler_h___ + +#include "nsIProtocolHandler.h" +#include "nsIObserver.h" +#include "nsIPrefBranch.h" +#include "nsStringFwd.h" + +#include "mozilla/Logging.h" +extern mozilla::LazyLogModule gGIOLog; + +class nsGIOProtocolHandler final : public nsIProtocolHandler, + public nsIObserver { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIPROTOCOLHANDLER + NS_DECL_NSIOBSERVER + + static already_AddRefed GetSingleton(); + bool IsSupportedProtocol(const nsCString& aScheme); + + protected: + ~nsGIOProtocolHandler() = default; + + private: + nsresult Init(); + + void InitSupportedProtocolsPref(nsIPrefBranch* prefs); + + static mozilla::StaticRefPtr sSingleton; + nsTArray mSupportedProtocols; +}; + +#endif // nsGIOProtocolHandler_h___ -- cgit v1.2.3