Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 4752 insertions, 0 deletions

diff --git a/sfx2/source/doc/docfile.cxx b/sfx2/source/doc/docfile.cxx
new file mode 100644
index 000000000..fafe05d15
--- /dev/null
+++ b/sfx2/source/doc/docfile.cxx
@@ -0,0 +1,4752 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.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 incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <config_features.h>
+
+#ifdef UNX
+#include <sys/stat.h>
+#endif
+
+#include <sfx2/docfile.hxx>
+#include <sfx2/signaturestate.hxx>
+
+#include <com/sun/star/task/InteractionHandler.hpp>
+#include <com/sun/star/task/XStatusIndicator.hpp>
+#include <com/sun/star/uno/Reference.h>
+#include <com/sun/star/ucb/XContent.hpp>
+#include <com/sun/star/container/XChild.hpp>
+#include <com/sun/star/document/XDocumentRevisionListPersistence.hpp>
+#include <com/sun/star/document/LockedDocumentRequest.hpp>
+#include <com/sun/star/document/LockedOnSavingRequest.hpp>
+#include <com/sun/star/document/OwnLockOnDocumentRequest.hpp>
+#include <com/sun/star/document/LockFileIgnoreRequest.hpp>
+#include <com/sun/star/document/LockFileCorruptRequest.hpp>
+#include <com/sun/star/document/ChangedByOthersRequest.hpp>
+#include <com/sun/star/document/ReloadEditableRequest.hpp>
+#include <com/sun/star/embed/XTransactedObject.hpp>
+#include <com/sun/star/embed/ElementModes.hpp>
+#include <com/sun/star/embed/UseBackupException.hpp>
+#include <com/sun/star/embed/XOptimizedStorage.hpp>
+#include <com/sun/star/frame/Desktop.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/frame/XTerminateListener.hpp>
+#include <com/sun/star/graphic/XGraphic.hpp>
+#include <com/sun/star/ucb/ContentCreationException.hpp>
+#include <com/sun/star/ucb/InteractiveIOException.hpp>
+#include <com/sun/star/ucb/CommandFailedException.hpp>
+#include <com/sun/star/ucb/CommandAbortedException.hpp>
+#include <com/sun/star/ucb/InteractiveLockingLockedException.hpp>
+#include <com/sun/star/ucb/InteractiveNetworkWriteException.hpp>
+#include <com/sun/star/ucb/Lock.hpp>
+#include <com/sun/star/ucb/NameClashException.hpp>
+#include <com/sun/star/ucb/XCommandEnvironment.hpp>
+#include <com/sun/star/ucb/XProgressHandler.hpp>
+#include <com/sun/star/io/XOutputStream.hpp>
+#include <com/sun/star/io/XInputStream.hpp>
+#include <com/sun/star/io/XTruncate.hpp>
+#include <com/sun/star/io/XSeekable.hpp>
+#include <com/sun/star/lang/XSingleServiceFactory.hpp>
+#include <com/sun/star/ucb/InsertCommandArgument.hpp>
+#include <com/sun/star/ucb/NameClash.hpp>
+#include <com/sun/star/beans/NamedValue.hpp>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/security/DocumentDigitalSignatures.hpp>
+#include <com/sun/star/security/XCertificate.hpp>
+#include <tools/urlobj.hxx>
+#include <tools/fileutil.hxx>
+#include <unotools/configmgr.hxx>
+#include <unotools/tempfile.hxx>
+#include <comphelper/fileurl.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/propertyvalue.hxx>
+#include <comphelper/interaction.hxx>
+#include <comphelper/sequence.hxx>
+#include <comphelper/simplefileaccessinteraction.hxx>
+#include <comphelper/string.hxx>
+#include <framework/interaction.hxx>
+#include <utility>
+#include <svl/stritem.hxx>
+#include <svl/eitem.hxx>
+#include <svtools/sfxecode.hxx>
+#include <svl/itemset.hxx>
+#include <svl/intitem.hxx>
+#include <svtools/svparser.hxx>
+#include <sal/log.hxx>
+
+#include <unotools/streamwrap.hxx>
+
+#include <osl/file.hxx>
+
+#include <comphelper/storagehelper.hxx>
+#include <unotools/mediadescriptor.hxx>
+#include <comphelper/docpasswordhelper.hxx>
+#include <tools/datetime.hxx>
+#include <unotools/pathoptions.hxx>
+#include <svtools/asynclink.hxx>
+#include <ucbhelper/commandenvironment.hxx>
+#include <unotools/ucbstreamhelper.hxx>
+#include <unotools/ucbhelper.hxx>
+#include <unotools/progresshandlerwrap.hxx>
+#include <ucbhelper/content.hxx>
+#include <ucbhelper/interactionrequest.hxx>
+#include <sot/storage.hxx>
+#include <svl/documentlockfile.hxx>
+#include <svl/msodocumentlockfile.hxx>
+#include <com/sun/star/document/DocumentRevisionListPersistence.hpp>
+
+#include <sfx2/app.hxx>
+#include <sfx2/frame.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/fcontnr.hxx>
+#include <sfx2/docfilt.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <sfx2/sfxuno.hxx>
+#include <openflag.hxx>
+#include <officecfg/Office/Common.hxx>
+#include <comphelper/propertysequence.hxx>
+#include <vcl/weld.hxx>
+#include <vcl/svapp.hxx>
+#include <tools/diagnose_ex.h>
+#include <unotools/fltrcfg.hxx>
+#include <sfx2/digitalsignatures.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <comphelper/threadpool.hxx>
+#include <o3tl/string_view.hxx>
+#include <condition_variable>
+
+#include <com/sun/star/io/WrongFormatException.hpp>
+
+#include <memory>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::graphic;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::ucb;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::io;
+using namespace ::com::sun::star::security;
+
+namespace
+{
+
+struct ReadOnlyMediumEntry
+{
+    ReadOnlyMediumEntry(std::shared_ptr<std::recursive_mutex> pMutex,
+                        std::shared_ptr<bool> pIsDestructed)
+        : _pMutex(pMutex)
+        , _pIsDestructed(pIsDestructed)
+    {
+    }
+    std::shared_ptr<std::recursive_mutex> _pMutex;
+    std::shared_ptr<bool> _pIsDestructed;
+};
+
+}
+
+static std::mutex g_chkReadOnlyGlobalMutex;
+static bool g_bChkReadOnlyTaskRunning = false;
+static std::unordered_map<SfxMedium*, std::shared_ptr<ReadOnlyMediumEntry>> g_newReadOnlyDocs;
+static std::unordered_map<SfxMedium*, std::shared_ptr<ReadOnlyMediumEntry>> g_existingReadOnlyDocs;
+
+namespace {
+
+#if HAVE_FEATURE_MULTIUSER_ENVIRONMENT
+
+bool IsSystemFileLockingUsed()
+{
+#if HAVE_FEATURE_MACOSX_SANDBOX
+    return true;
+#else
+    return officecfg::Office::Common::Misc::UseDocumentSystemFileLocking::get();
+#endif
+}
+
+
+bool IsOOoLockFileUsed()
+{
+#if HAVE_FEATURE_MACOSX_SANDBOX
+    return false;
+#else
+    return officecfg::Office::Common::Misc::UseDocumentOOoLockFile::get();
+#endif
+}
+
+bool IsLockingUsed()
+{
+    return officecfg::Office::Common::Misc::UseLocking::get();
+}
+
+#endif
+
+#if HAVE_FEATURE_MULTIUSER_ENVIRONMENT
+bool IsWebDAVLockingUsed()
+{
+    return officecfg::Office::Common::Misc::UseWebDAVFileLocking::get();
+}
+#endif
+
+/// Gets default attributes of a file:// URL.
+sal_uInt64 GetDefaultFileAttributes(const OUString& rURL)
+{
+    sal_uInt64 nRet = 0;
+
+    if (!comphelper::isFileUrl(rURL))
+        return nRet;
+
+    // Make sure the file exists (and create it if not).
+    osl::File aFile(rURL);
+    osl::File::RC nRes = aFile.open(osl_File_OpenFlag_Create);
+    if (nRes != osl::File::E_None && nRes != osl::File::E_EXIST)
+        return nRet;
+
+    aFile.close();
+
+    osl::DirectoryItem aItem;
+    if (osl::DirectoryItem::get(rURL, aItem) != osl::DirectoryItem::E_None)
+        return nRet;
+
+    osl::FileStatus aStatus(osl_FileStatus_Mask_Attributes);
+    if (aItem.getFileStatus(aStatus) != osl::DirectoryItem::E_None)
+        return nRet;
+
+    nRet = aStatus.getAttributes();
+    return nRet;
+}
+
+/// Determines if rURL is safe to move or not.
+bool IsFileMovable(const INetURLObject& rURL)
+{
+#ifdef MACOSX
+    (void)rURL;
+    // Hide extension macOS-specific file property would be lost.
+    return false;
+#else
+
+    if (rURL.GetProtocol() != INetProtocol::File)
+        // Not a file:// URL.
+        return false;
+
+#ifdef UNX
+    OUString sPath = rURL.getFSysPath(FSysStyle::Unix);
+    if (sPath.isEmpty())
+        return false;
+
+    struct stat buf;
+    if (lstat(sPath.toUtf8().getStr(), &buf) != 0)
+        return false;
+
+    // Hardlink or symlink: osl::File::move() doesn't play with these nicely.
+    if (buf.st_nlink > 1 || S_ISLNK(buf.st_mode))
+        return false;
+#elif defined _WIN32
+    if (tools::IsMappedWebDAVPath(rURL.GetMainURL(INetURLObject::DecodeMechanism::NONE)))
+        return false;
+#endif
+
+    return true;
+#endif
+}
+
+class CheckReadOnlyTaskTerminateListener
+    : public ::cppu::WeakImplHelper<css::frame::XTerminateListener>
+{
+public:
+    // XEventListener
+    void SAL_CALL disposing(const css::lang::EventObject& Source) override;
+
+    // XTerminateListener
+    void SAL_CALL queryTermination(const css::lang::EventObject& aEvent) override;
+    void SAL_CALL notifyTermination(const css::lang::EventObject& aEvent) override;
+
+    bool bIsTerminated = false;
+    std::condition_variable mCond;
+    std::mutex mMutex;
+};
+
+class CheckReadOnlyTask : public comphelper::ThreadTask
+{
+public:
+    CheckReadOnlyTask(const std::shared_ptr<comphelper::ThreadTaskTag>& pTag);
+    ~CheckReadOnlyTask();
+
+    virtual void doWork() override;
+
+private:
+    rtl::Reference<CheckReadOnlyTaskTerminateListener> m_xListener;
+};
+
+} // anonymous namespace
+
+CheckReadOnlyTask::CheckReadOnlyTask(const std::shared_ptr<comphelper::ThreadTaskTag>& pTag)
+    : ThreadTask(pTag)
+    , m_xListener(new CheckReadOnlyTaskTerminateListener)
+{
+    Reference<css::frame::XDesktop> xDesktop
+        = css::frame::Desktop::create(comphelper::getProcessComponentContext());
+    if (xDesktop.is() && m_xListener != nullptr)
+    {
+        xDesktop->addTerminateListener(m_xListener);
+    }
+}
+
+CheckReadOnlyTask::~CheckReadOnlyTask()
+{
+    Reference<css::frame::XDesktop> xDesktop
+        = css::frame::Desktop::create(comphelper::getProcessComponentContext());
+    if (xDesktop.is() && m_xListener != nullptr)
+    {
+        std::unique_lock<std::mutex> lock(m_xListener->mMutex);
+        if (!m_xListener->bIsTerminated)
+        {
+            lock.unlock();
+            xDesktop->removeTerminateListener(m_xListener);
+        }
+    }
+}
+
+namespace
+{
+void SAL_CALL
+CheckReadOnlyTaskTerminateListener::disposing(const css::lang::EventObject& /*Source*/)
+{
+}
+
+void SAL_CALL
+CheckReadOnlyTaskTerminateListener::queryTermination(const css::lang::EventObject& /*aEvent*/)
+{
+}
+
+void SAL_CALL
+CheckReadOnlyTaskTerminateListener::notifyTermination(const css::lang::EventObject& /*aEvent*/)
+{
+    std::unique_lock<std::mutex> lock(mMutex);
+    bIsTerminated = true;
+    lock.unlock();
+    mCond.notify_one();
+}
+}
+
+class SfxMedium_Impl
+{
+public:
+    StreamMode m_nStorOpenMode;
+    ErrCode    m_eError;
+
+    ::ucbhelper::Content aContent;
+    bool bUpdatePickList:1;
+    bool bIsTemp:1;
+    bool bDownloadDone:1;
+    bool bIsStorage:1;
+    bool bUseInteractionHandler:1;
+    bool bAllowDefaultIntHdl:1;
+    bool bDisposeStorage:1;
+    bool bStorageBasedOnInStream:1;
+    bool m_bSalvageMode:1;
+    bool m_bVersionsAlreadyLoaded:1;
+    bool m_bLocked:1;
+    bool m_bMSOLockFileCreated : 1;
+    bool m_bDisableUnlockWebDAV:1;
+    bool m_bGotDateTime:1;
+    bool m_bRemoveBackup:1;
+    bool m_bOriginallyReadOnly:1;
+    bool m_bOriginallyLoadedReadOnly:1;
+    bool m_bTriedStorage:1;
+    bool m_bRemote:1;
+    bool m_bInputStreamIsReadOnly:1;
+    bool m_bInCheckIn:1;
+    bool m_bDisableFileSync = false;
+    bool m_bNotifyWhenEditable = false;
+
+    OUString m_aName;
+    OUString m_aLogicName;
+    OUString m_aLongName;
+
+    mutable std::shared_ptr<SfxItemSet> m_pSet;
+    mutable std::unique_ptr<INetURLObject> m_pURLObj;
+
+    std::shared_ptr<const SfxFilter> m_pFilter;
+    std::shared_ptr<const SfxFilter> m_pCustomFilter;
+
+    std::shared_ptr<std::recursive_mutex> m_pCheckEditableWorkerMutex;
+    std::shared_ptr<bool> m_pIsDestructed;
+    ImplSVEvent* m_pReloadEvent;
+
+    std::unique_ptr<SvStream> m_pInStream;
+    std::unique_ptr<SvStream> m_pOutStream;
+
+    OUString    aOrigURL;
+    DateTime         aExpireTime;
+    SfxFrameWeakRef  wLoadTargetFrame;
+    SvKeyValueIteratorRef xAttributes;
+
+    svtools::AsynchronLink  aDoneLink;
+
+    uno::Sequence < util::RevisionTag > aVersions;
+
+    std::unique_ptr<::utl::TempFile> pTempFile;
+
+    uno::Reference<embed::XStorage> xStorage;
+    uno::Reference<embed::XStorage> m_xZipStorage;
+    uno::Reference<io::XInputStream> m_xInputStreamToLoadFrom;
+    uno::Reference<io::XInputStream> xInputStream;
+    uno::Reference<io::XStream> xStream;
+    uno::Reference<io::XStream> m_xLockingStream;
+    uno::Reference<task::XInteractionHandler> xInteraction;
+
+    ErrCode  nLastStorageError;
+
+    OUString m_aBackupURL;
+
+    // the following member is changed and makes sense only during saving
+    // TODO/LATER: in future the signature state should be controlled by the medium not by the document
+    //             in this case the member will hold this information
+    SignatureState             m_nSignatureState;
+
+    bool m_bHasEmbeddedObjects = false;
+
+    util::DateTime m_aDateTime;
+
+    uno::Sequence<beans::PropertyValue> m_aArgs;
+
+    explicit SfxMedium_Impl();
+    ~SfxMedium_Impl();
+    SfxMedium_Impl(const SfxMedium_Impl&) = delete;
+    SfxMedium_Impl& operator=(const SfxMedium_Impl&) = delete;
+
+    OUString getFilterMimeType() const
+        { return !m_pFilter ? OUString() : m_pFilter->GetMimeType(); }
+};
+
+SfxMedium_Impl::SfxMedium_Impl() :
+    m_nStorOpenMode(SFX_STREAM_READWRITE),
+    m_eError(ERRCODE_NONE),
+    bUpdatePickList(true),
+    bIsTemp( false ),
+    bDownloadDone( true ),
+    bIsStorage( false ),
+    bUseInteractionHandler( true ),
+    bAllowDefaultIntHdl( false ),
+    bDisposeStorage( false ),
+    bStorageBasedOnInStream( false ),
+    m_bSalvageMode( false ),
+    m_bVersionsAlreadyLoaded( false ),
+    m_bLocked( false ),
+    m_bMSOLockFileCreated( false ),
+    m_bDisableUnlockWebDAV( false ),
+    m_bGotDateTime( false ),
+    m_bRemoveBackup( false ),
+    m_bOriginallyReadOnly(false),
+    m_bOriginallyLoadedReadOnly(false),
+    m_bTriedStorage(false),
+    m_bRemote(false),
+    m_bInputStreamIsReadOnly(false),
+    m_bInCheckIn(false),
+    m_pReloadEvent(nullptr),
+    aExpireTime( DateTime( DateTime::SYSTEM ) + static_cast<sal_Int32>(10) ),
+    nLastStorageError( ERRCODE_NONE ),
+    m_nSignatureState( SignatureState::NOSIGNATURES )
+{
+}
+
+
+SfxMedium_Impl::~SfxMedium_Impl()
+{
+    aDoneLink.ClearPendingCall();
+
+    pTempFile.reset();
+    m_pSet.reset();
+    std::unique_lock<std::recursive_mutex> chkEditLock;
+    if (m_pCheckEditableWorkerMutex != nullptr)
+        chkEditLock = std::unique_lock<std::recursive_mutex>(*m_pCheckEditableWorkerMutex);
+    m_pURLObj.reset();
+}
+
+void SfxMedium::ResetError()
+{
+    pImpl->m_eError = ERRCODE_NONE;
+    if( pImpl->m_pInStream )
+        pImpl->m_pInStream->ResetError();
+    if( pImpl->m_pOutStream )
+        pImpl->m_pOutStream->ResetError();
+}
+
+ErrCode const & SfxMedium::GetLastStorageCreationState() const
+{
+    return pImpl->nLastStorageError;
+}
+
+void SfxMedium::SetError(ErrCode nError)
+{
+    pImpl->m_eError = nError;
+}
+
+ErrCode SfxMedium::GetErrorCode() const
+{
+    ErrCode lError = pImpl->m_eError;
+    if(!lError && pImpl->m_pInStream)
+        lError = pImpl->m_pInStream->GetErrorCode();
+    if(!lError && pImpl->m_pOutStream)
+        lError = pImpl->m_pOutStream->GetErrorCode();
+    return lError;
+}
+
+void SfxMedium::CheckFileDate( const util::DateTime& aInitDate )
+{
+    GetInitFileDate( true );
+    if ( pImpl->m_aDateTime.Seconds == aInitDate.Seconds
+      && pImpl->m_aDateTime.Minutes == aInitDate.Minutes
+      && pImpl->m_aDateTime.Hours == aInitDate.Hours
+      && pImpl->m_aDateTime.Day == aInitDate.Day
+      && pImpl->m_aDateTime.Month == aInitDate.Month
+      && pImpl->m_aDateTime.Year == aInitDate.Year )
+        return;
+
+    uno::Reference< task::XInteractionHandler > xHandler = GetInteractionHandler();
+
+    if ( !xHandler.is() )
+        return;
+
+    try
+    {
+        ::rtl::Reference< ::ucbhelper::InteractionRequest > xInteractionRequestImpl = new ::ucbhelper::InteractionRequest( uno::Any(
+            document::ChangedByOthersRequest() ) );
+        uno::Sequence< uno::Reference< task::XInteractionContinuation > > aContinuations{
+            new ::ucbhelper::InteractionAbort( xInteractionRequestImpl.get() ),
+            new ::ucbhelper::InteractionApprove( xInteractionRequestImpl.get() )
+        };
+        xInteractionRequestImpl->setContinuations( aContinuations );
+
+        xHandler->handle( xInteractionRequestImpl );
+
+        ::rtl::Reference< ::ucbhelper::InteractionContinuation > xSelected = xInteractionRequestImpl->getSelection();
+        if ( uno::Reference< task::XInteractionAbort >( xSelected.get(), uno::UNO_QUERY ).is() )
+        {
+            SetError(ERRCODE_ABORT);
+        }
+    }
+    catch ( const uno::Exception& )
+    {}
+}
+
+bool SfxMedium::DocNeedsFileDateCheck() const
+{
+    return ( !IsReadOnly() && ( GetURLObject().GetProtocol() == INetProtocol::File ||
+                                GetURLObject().isAnyKnownWebDAVScheme() ) );
+}
+
+util::DateTime const & SfxMedium::GetInitFileDate( bool bIgnoreOldValue )
+{
+    if ( ( bIgnoreOldValue || !pImpl->m_bGotDateTime ) && !pImpl->m_aLogicName.isEmpty() )
+    {
+        try
+        {
+            // add a default css::ucb::XCommandEnvironment
+            // in order to have the WebDAV UCP provider manage http/https authentication correctly
+            ::ucbhelper::Content aContent( GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ),
+                                           utl::UCBContentHelper::getDefaultCommandEnvironment(),
+                                           comphelper::getProcessComponentContext() );
+
+            aContent.getPropertyValue("DateModified") >>= pImpl->m_aDateTime;
+            pImpl->m_bGotDateTime = true;
+        }
+        catch ( const css::uno::Exception& )
+        {
+        }
+    }
+
+    return pImpl->m_aDateTime;
+}
+
+
+Reference < XContent > SfxMedium::GetContent() const
+{
+    if ( !pImpl->aContent.get().is() )
+    {
+        Reference < css::ucb::XContent > xContent;
+
+        // tdf#95144 add a default css::ucb::XCommandEnvironment
+        // in order to have the WebDAV UCP provider manage https protocol certificates correctly
+        css:: uno::Reference< task::XInteractionHandler > xIH(
+                css::task::InteractionHandler::createWithParent( comphelper::getProcessComponentContext(), nullptr ) );
+
+        css::uno::Reference< css::ucb::XProgressHandler > xProgress;
+        rtl::Reference<::ucbhelper::CommandEnvironment> pCommandEnv = new ::ucbhelper::CommandEnvironment( new comphelper::SimpleFileAccessInteraction( xIH ), xProgress );
+
+        const SfxUnoAnyItem* pItem = SfxItemSet::GetItem<SfxUnoAnyItem>(pImpl->m_pSet.get(), SID_CONTENT, false);
+        if ( pItem )
+            pItem->GetValue() >>= xContent;
+
+        if ( xContent.is() )
+        {
+            try
+            {
+                pImpl->aContent = ::ucbhelper::Content( xContent, pCommandEnv, comphelper::getProcessComponentContext() );
+            }
+            catch ( const Exception& )
+            {
+            }
+        }
+        else
+        {
+            // TODO: SAL_WARN( "sfx.doc", "SfxMedium::GetContent()\nCreate Content? This code exists as fallback only. Please clarify, why it's used.");
+            OUString aURL;
+            if ( !pImpl->m_aName.isEmpty() )
+                osl::FileBase::getFileURLFromSystemPath( pImpl->m_aName, aURL );
+            else if ( !pImpl->m_aLogicName.isEmpty() )
+                aURL = GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE );
+            if (!aURL.isEmpty() )
+                (void)::ucbhelper::Content::create( aURL, pCommandEnv, comphelper::getProcessComponentContext(), pImpl->aContent );
+        }
+    }
+
+    return pImpl->aContent.get();
+}
+
+OUString SfxMedium::GetBaseURL( bool bForSaving )
+{
+    OUString aBaseURL;
+    const SfxStringItem* pBaseURLItem = GetItemSet()->GetItem<SfxStringItem>(SID_DOC_BASEURL);
+    if ( pBaseURLItem )
+        aBaseURL = pBaseURLItem->GetValue();
+    else if (!utl::ConfigManager::IsFuzzing() && GetContent().is())
+    {
+        try
+        {
+            Any aAny = pImpl->aContent.getPropertyValue("BaseURI");
+            aAny >>= aBaseURL;
+        }
+        catch ( const css::uno::Exception& )
+        {
+        }
+
+        if ( aBaseURL.isEmpty() )
+            aBaseURL = GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE );
+    }
+
+    if ( bForSaving )
+    {
+        bool bIsRemote = IsRemote();
+        if( (bIsRemote && !officecfg::Office::Common::Save::URL::Internet::get())
+            || (!pImpl->m_bRemote && !officecfg::Office::Common::Save::URL::FileSystem::get()) )
+            return OUString();
+    }
+
+    return aBaseURL;
+}
+
+bool SfxMedium::IsSkipImages() const
+{
+    const SfxStringItem* pSkipImagesItem = GetItemSet()->GetItem<SfxStringItem>(SID_FILE_FILTEROPTIONS);
+    return pSkipImagesItem && pSkipImagesItem->GetValue() == "SkipImages";
+}
+
+SvStream* SfxMedium::GetInStream()
+{
+    if ( pImpl->m_pInStream )
+        return pImpl->m_pInStream.get();
+
+    if ( pImpl->pTempFile )
+    {
+        pImpl->m_pInStream.reset( new SvFileStream(pImpl->m_aName, pImpl->m_nStorOpenMode) );
+
+        pImpl->m_eError = pImpl->m_pInStream->GetError();
+
+        if (!pImpl->m_eError && (pImpl->m_nStorOpenMode & StreamMode::WRITE)
+                    && ! pImpl->m_pInStream->IsWritable() )
+        {
+            pImpl->m_eError = ERRCODE_IO_ACCESSDENIED;
+            pImpl->m_pInStream.reset();
+        }
+        else
+            return pImpl->m_pInStream.get();
+    }
+
+    GetMedium_Impl();
+
+    if ( GetError() )
+        return nullptr;
+
+    return pImpl->m_pInStream.get();
+}
+
+
+void SfxMedium::CloseInStream()
+{
+    CloseInStream_Impl();
+}
+
+void SfxMedium::CloseInStream_Impl(bool bInDestruction)
+{
+    // if there is a storage based on the InStream, we have to
+    // close the storage, too, because otherwise the storage
+    // would use an invalid ( deleted ) stream.
+    if ( pImpl->m_pInStream && pImpl->xStorage.is() )
+    {
+        if ( pImpl->bStorageBasedOnInStream )
+            CloseStorage();
+    }
+
+    if ( pImpl->m_pInStream && !GetContent().is() && !bInDestruction )
+    {
+        CreateTempFile();
+        return;
+    }
+
+    pImpl->m_pInStream.reset();
+    if ( pImpl->m_pSet )
+        pImpl->m_pSet->ClearItem( SID_INPUTSTREAM );
+
+    CloseZipStorage_Impl();
+    pImpl->xInputStream.clear();
+
+    if ( !pImpl->m_pOutStream )
+    {
+        // output part of the stream is not used so the whole stream can be closed
+        // TODO/LATER: is it correct?
+        pImpl->xStream.clear();
+        if ( pImpl->m_pSet )
+            pImpl->m_pSet->ClearItem( SID_STREAM );
+    }
+}
+
+
+SvStream* SfxMedium::GetOutStream()
+{
+    if ( !pImpl->m_pOutStream )
+    {
+        // Create a temp. file if there is none because we always
+        // need one.
+        CreateTempFile( false );
+
+        if ( pImpl->pTempFile )
+        {
+            // On windows we try to re-use XOutStream from xStream if that exists;
+            // because opening new SvFileStream in this situation may fail with ERROR_SHARING_VIOLATION
+            // TODO: this is a horrible hack that should probably be removed,
+            // somebody needs to investigate this more thoroughly...
+            if (getenv("SFX_MEDIUM_REUSE_STREAM") && pImpl->xStream.is())
+            {
+                assert(pImpl->xStream->getOutputStream().is()); // need that...
+                pImpl->m_pOutStream = utl::UcbStreamHelper::CreateStream(
+                        pImpl->xStream, false);
+            }
+            else
+            {
+            // On Unix don't try to re-use XOutStream from xStream if that exists;
+            // it causes fdo#59022 (fails opening files via SMB on Linux)
+                pImpl->m_pOutStream.reset( new SvFileStream(
+                            pImpl->m_aName, StreamMode::STD_READWRITE) );
+            }
+            CloseStorage();
+        }
+    }
+
+    return pImpl->m_pOutStream.get();
+}
+
+
+void SfxMedium::CloseOutStream()
+{
+    CloseOutStream_Impl();
+}
+
+void SfxMedium::CloseOutStream_Impl()
+{
+    if ( pImpl->m_pOutStream )
+    {
+        // if there is a storage based on the OutStream, we have to
+        // close the storage, too, because otherwise the storage
+        // would use an invalid ( deleted ) stream.
+        //TODO/MBA: how to deal with this?!
+        //maybe we need a new flag when the storage was created from the outstream
+        if ( pImpl->xStorage.is() )
+        {
+                CloseStorage();
+        }
+
+        pImpl->m_pOutStream.reset();
+    }
+
+    if ( !pImpl->m_pInStream )
+    {
+        // input part of the stream is not used so the whole stream can be closed
+        // TODO/LATER: is it correct?
+        pImpl->xStream.clear();
+        if ( pImpl->m_pSet )
+            pImpl->m_pSet->ClearItem( SID_STREAM );
+    }
+}
+
+
+const OUString& SfxMedium::GetPhysicalName() const
+{
+    if ( pImpl->m_aName.isEmpty() && !pImpl->m_aLogicName.isEmpty() )
+        const_cast<SfxMedium*>(this)->CreateFileStream();
+
+    // return the name then
+    return pImpl->m_aName;
+}
+
+
+void SfxMedium::CreateFileStream()
+{
+    // force synchron
+    if( pImpl->m_pInStream )
+    {
+        SvLockBytes* pBytes = pImpl->m_pInStream->GetLockBytes();
+        if( pBytes )
+            pBytes->SetSynchronMode();
+    }
+
+    GetInStream();
+    if( pImpl->m_pInStream )
+    {
+        CreateTempFile( false );
+        pImpl->bIsTemp = true;
+        CloseInStream_Impl();
+    }
+}
+
+
+bool SfxMedium::Commit()
+{
+    if( pImpl->xStorage.is() )
+        StorageCommit_Impl();
+    else if( pImpl->m_pOutStream  )
+        pImpl->m_pOutStream->FlushBuffer();
+    else if( pImpl->m_pInStream  )
+        pImpl->m_pInStream->FlushBuffer();
+
+    if ( GetError() == ERRCODE_NONE )
+    {
+        // does something only in case there is a temporary file ( means aName points to different location than aLogicName )
+        Transfer_Impl();
+    }
+
+    bool bResult = ( GetError() == ERRCODE_NONE );
+
+    if ( bResult && DocNeedsFileDateCheck() )
+        GetInitFileDate( true );
+
+    // remove truncation mode from the flags
+    pImpl->m_nStorOpenMode &= ~StreamMode::TRUNC;
+    return bResult;
+}
+
+
+bool SfxMedium::IsStorage()
+{
+    if ( pImpl->xStorage.is() )
+        return true;
+
+    if ( pImpl->m_bTriedStorage )
+        return pImpl->bIsStorage;
+
+    if ( pImpl->pTempFile )
+    {
+        OUString aURL;
+        if ( osl::FileBase::getFileURLFromSystemPath( pImpl->m_aName, aURL )
+             != osl::FileBase::E_None )
+        {
+            SAL_WARN( "sfx.doc", "Physical name '" << pImpl->m_aName << "' not convertible to file URL");
+        }
+        pImpl->bIsStorage = SotStorage::IsStorageFile( aURL ) && !SotStorage::IsOLEStorage( aURL);
+        if ( !pImpl->bIsStorage )
+            pImpl->m_bTriedStorage = true;
+    }
+    else if ( GetInStream() )
+    {
+        pImpl->bIsStorage = SotStorage::IsStorageFile( pImpl->m_pInStream.get() ) && !SotStorage::IsOLEStorage( pImpl->m_pInStream.get() );
+        if ( !pImpl->m_pInStream->GetError() && !pImpl->bIsStorage )
+            pImpl->m_bTriedStorage = true;
+    }
+
+    return pImpl->bIsStorage;
+}
+
+
+bool SfxMedium::IsPreview_Impl() const
+{
+    bool bPreview = false;
+    const SfxBoolItem* pPreview = SfxItemSet::GetItem<SfxBoolItem>(GetItemSet(), SID_PREVIEW, false);
+    if ( pPreview )
+        bPreview = pPreview->GetValue();
+    else
+    {
+        const SfxStringItem* pFlags = SfxItemSet::GetItem<SfxStringItem>(GetItemSet(), SID_OPTIONS, false);
+        if ( pFlags )
+        {
+            OUString aFileFlags = pFlags->GetValue();
+            aFileFlags = aFileFlags.toAsciiUpperCase();
+            if ( -1 != aFileFlags.indexOf( 'B' ) )
+                bPreview = true;
+        }
+    }
+
+    return bPreview;
+}
+
+
+void SfxMedium::StorageBackup_Impl()
+{
+    ::ucbhelper::Content aOriginalContent;
+    Reference< css::ucb::XCommandEnvironment > xDummyEnv;
+
+    bool bBasedOnOriginalFile =
+        !pImpl->pTempFile
+        && ( pImpl->m_aLogicName.isEmpty() || !pImpl->m_bSalvageMode )
+        && !GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ).isEmpty()
+        && GetURLObject().GetProtocol() == INetProtocol::File
+        && ::utl::UCBContentHelper::IsDocument( GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
+
+    if ( bBasedOnOriginalFile && pImpl->m_aBackupURL.isEmpty()
+      && ::ucbhelper::Content::create( GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ), xDummyEnv, comphelper::getProcessComponentContext(), aOriginalContent ) )
+    {
+        DoInternalBackup_Impl( aOriginalContent );
+        if( pImpl->m_aBackupURL.isEmpty() )
+            SetError(ERRCODE_SFX_CANTCREATEBACKUP);
+    }
+}
+
+
+OUString const & SfxMedium::GetBackup_Impl()
+{
+    if ( pImpl->m_aBackupURL.isEmpty() )
+        StorageBackup_Impl();
+
+    return pImpl->m_aBackupURL;
+}
+
+
+uno::Reference < embed::XStorage > SfxMedium::GetOutputStorage()
+{
+    if ( GetError() )
+        return uno::Reference< embed::XStorage >();
+
+    // if the medium was constructed with a Storage: use this one, not a temp. storage
+    // if a temporary storage already exists: use it
+    if ( pImpl->xStorage.is() && ( pImpl->m_aLogicName.isEmpty() || pImpl->pTempFile ) )
+        return pImpl->xStorage;
+
+    // if necessary close stream that was used for reading
+    if ( pImpl->m_pInStream && !pImpl->m_pInStream->IsWritable() )
+        CloseInStream();
+
+    DBG_ASSERT( !pImpl->m_pOutStream, "OutStream in a readonly Medium?!" );
+
+    // TODO/LATER: The current solution is to store the document temporary and then copy it to the target location;
+    // in future it should be stored directly and then copied to the temporary location, since in this case no
+    // file attributes have to be preserved and system copying mechanics could be used instead of streaming.
+    CreateTempFileNoCopy();
+
+    return GetStorage();
+}
+
+
+void SfxMedium::SetEncryptionDataToStorage_Impl()
+{
+    // in case media-descriptor contains password it should be used on opening
+    if ( !pImpl->xStorage.is() || !pImpl->m_pSet )
+        return;
+
+    uno::Sequence< beans::NamedValue > aEncryptionData;
+    if ( !GetEncryptionData_Impl( pImpl->m_pSet.get(), aEncryptionData ) )
+        return;
+
+    // replace the password with encryption data
+    pImpl->m_pSet->ClearItem( SID_PASSWORD );
+    pImpl->m_pSet->Put( SfxUnoAnyItem( SID_ENCRYPTIONDATA, uno::Any( aEncryptionData ) ) );
+
+    try
+    {
+        ::comphelper::OStorageHelper::SetCommonStorageEncryptionData( pImpl->xStorage, aEncryptionData );
+    }
+    catch( const uno::Exception& )
+    {
+        SAL_WARN( "sfx.doc", "It must be possible to set a common password for the storage" );
+        // TODO/LATER: set the error code in case of problem
+        // SetError(ERRCODE_IO_GENERAL);
+    }
+}
+
+#if HAVE_FEATURE_MULTIUSER_ENVIRONMENT
+
+// FIXME: Hmm actually lock files should be used for sftp: documents
+// even if !HAVE_FEATURE_MULTIUSER_ENVIRONMENT. Only the use of lock
+// files for *local* documents is unnecessary in that case. But
+// actually, the checks for sftp: here are just wishful thinking; I
+// don't this there is any support for actually editing documents
+// behind sftp: URLs anyway.
+
+// Sure, there could perhaps be a 3rd-party extension that brings UCB
+// the potential to handle files behind sftp:. But there could also be
+// an extension that handles some arbitrary foobar: scheme *and* it
+// could be that lock files would be the correct thing to use for
+// foobar: documents, too. But the hardcoded test below won't know
+// that. Clearly the knowledge whether lock files should be used or
+// not for some URL scheme belongs in UCB, not here.
+
+namespace
+{
+
+OUString tryMSOwnerFiles(std::u16string_view sDocURL)
+{
+    svt::MSODocumentLockFile aMSOLockFile(sDocURL);
+    LockFileEntry aData;
+    try
+    {
+        aData = aMSOLockFile.GetLockData();
+    }
+    catch( const uno::Exception& )
+    {
+        return OUString();
+    }
+
+    OUString sUserData = aData[LockFileComponent::OOOUSERNAME];
+
+    if (!sUserData.isEmpty())
+        sUserData += " (MS Office)"; // Mention the used office suite
+
+    return sUserData;
+}
+
+OUString tryForeignLockfiles(std::u16string_view sDocURL)
+{
+    OUString sUserData = tryMSOwnerFiles(sDocURL);
+    // here we can test for empty result, and add other known applications' lockfile testing
+    return sUserData.trim();
+}
+}
+
+SfxMedium::ShowLockResult SfxMedium::ShowLockedDocumentDialog(const LockFileEntry& aData,
+                                                              bool bIsLoading, bool bOwnLock,
+                                                              bool bHandleSysLocked)
+{
+    ShowLockResult nResult = ShowLockResult::NoLock;
+
+    // tdf#92817: Simple check for empty lock file that needs to be deleted, when system locking is enabled
+    if( aData[LockFileComponent::OOOUSERNAME].isEmpty() && aData[LockFileComponent::SYSUSERNAME].isEmpty() && !bHandleSysLocked )
+        bOwnLock=true;
+
+    // show the interaction regarding the document opening
+    uno::Reference< task::XInteractionHandler > xHandler = GetInteractionHandler();
+
+    if ( xHandler.is() && ( bIsLoading || !bHandleSysLocked || bOwnLock ) )
+    {
+        OUString aDocumentURL
+            = GetURLObject().GetLastName(INetURLObject::DecodeMechanism::WithCharset);
+        OUString aInfo;
+        ::rtl::Reference< ::ucbhelper::InteractionRequest > xInteractionRequestImpl;
+
+        sal_Int32 nContinuations = 3;
+
+        if ( bOwnLock )
+        {
+            aInfo = aData[LockFileComponent::EDITTIME];
+
+            xInteractionRequestImpl = new ::ucbhelper::InteractionRequest( uno::Any(
+                document::OwnLockOnDocumentRequest( OUString(), uno::Reference< uno::XInterface >(), aDocumentURL, aInfo, !bIsLoading ) ) );
+        }
+        else
+        {
+            // Use a fourth continuation in case there's no filesystem lock:
+            // "Ignore lock file and open/replace the document"
+            if (!bHandleSysLocked)
+                nContinuations = 4;
+
+            if ( !aData[LockFileComponent::OOOUSERNAME].isEmpty() )
+                aInfo = aData[LockFileComponent::OOOUSERNAME];
+            else
+                aInfo = aData[LockFileComponent::SYSUSERNAME];
+
+            if (aInfo.isEmpty() && !GetURLObject().isAnyKnownWebDAVScheme())
+                // Try to get name of user who has locked the file using other applications
+                aInfo = tryForeignLockfiles(
+                    GetURLObject().GetMainURL(INetURLObject::DecodeMechanism::NONE));
+
+            if ( !aInfo.isEmpty() && !aData[LockFileComponent::EDITTIME].isEmpty() )
+                aInfo += " ( " + aData[LockFileComponent::EDITTIME] + " )";
+
+            if (!bIsLoading) // so, !bHandleSysLocked
+            {
+                xInteractionRequestImpl = new ::ucbhelper::InteractionRequest(uno::Any(
+                    document::LockedOnSavingRequest(OUString(), uno::Reference< uno::XInterface >(), aDocumentURL, aInfo)));
+                // Currently, only the last "Retry" continuation (meaning ignore the lock and try overwriting) can be returned.
+            }
+            else /*logically therefore bIsLoading is set */
+            {
+                xInteractionRequestImpl = new ::ucbhelper::InteractionRequest( uno::Any(
+                    document::LockedDocumentRequest( OUString(), uno::Reference< uno::XInterface >(), aDocumentURL, aInfo ) ) );
+            }
+        }
+
+        uno::Sequence< uno::Reference< task::XInteractionContinuation > > aContinuations(nContinuations);
+        auto pContinuations = aContinuations.getArray();
+        pContinuations[0] = new ::ucbhelper::InteractionAbort( xInteractionRequestImpl.get() );
+        pContinuations[1] = new ::ucbhelper::InteractionApprove( xInteractionRequestImpl.get() );
+        pContinuations[2] = new ::ucbhelper::InteractionDisapprove( xInteractionRequestImpl.get() );
+        if (nContinuations > 3)
+        {
+            // We use InteractionRetry to reflect that user wants to
+            // ignore the (stale?) alien lock file and open/overwrite the document
+            pContinuations[3] = new ::ucbhelper::InteractionRetry(xInteractionRequestImpl.get());
+        }
+        xInteractionRequestImpl->setContinuations( aContinuations );
+
+        xHandler->handle( xInteractionRequestImpl );
+
+        bool bOpenReadOnly = false;
+        ::rtl::Reference< ::ucbhelper::InteractionContinuation > xSelected = xInteractionRequestImpl->getSelection();
+        if ( uno::Reference< task::XInteractionAbort >( xSelected.get(), uno::UNO_QUERY ).is() )
+        {
+            SetError(ERRCODE_ABORT);
+        }
+        else if ( uno::Reference< task::XInteractionDisapprove >( xSelected.get(), uno::UNO_QUERY ).is() )
+        {
+            // own lock on loading, user has selected to ignore the lock
+            // own lock on saving, user has selected to ignore the lock
+            // alien lock on loading, user has selected to edit a copy of document
+            // TODO/LATER: alien lock on saving, user has selected to do SaveAs to different location
+            if ( !bOwnLock ) // bIsLoading implied from outermost condition
+            {
+                // means that a copy of the document should be opened
+                GetItemSet()->Put( SfxBoolItem( SID_TEMPLATE, true ) );
+            }
+            else
+                nResult = ShowLockResult::Succeeded;
+        }
+        else if (uno::Reference< task::XInteractionRetry >(xSelected.get(), uno::UNO_QUERY).is())
+        {
+            // User decided to ignore the alien (stale?) lock file without filesystem lock
+            nResult = ShowLockResult::Succeeded;
+        }
+        else if (uno::Reference< task::XInteractionApprove >( xSelected.get(), uno::UNO_QUERY ).is())
+        {
+            bOpenReadOnly = true;
+        }
+        else // user selected "Notify"
+        {
+            pImpl->m_bNotifyWhenEditable = true;
+            AddToCheckEditableWorkerList();
+            bOpenReadOnly = true;
+        }
+
+        if (bOpenReadOnly)
+        {
+            // own lock on loading, user has selected to open readonly
+            // own lock on saving, user has selected to open readonly
+            // alien lock on loading, user has selected to retry saving
+            // TODO/LATER: alien lock on saving, user has selected to retry saving
+
+            if (bIsLoading)
+                GetItemSet()->Put(SfxBoolItem(SID_DOC_READONLY, true));
+            else
+                nResult = ShowLockResult::Try;
+        }
+    }
+    else
+    {
+        if ( bIsLoading )
+        {
+            // if no interaction handler is provided the default answer is open readonly
+            // that usually happens in case the document is loaded per API
+            // so the document must be opened readonly for backward compatibility
+            GetItemSet()->Put( SfxBoolItem( SID_DOC_READONLY, true ) );
+        }
+        else
+            SetError(ERRCODE_IO_ACCESSDENIED);
+
+    }
+
+    return nResult;
+}
+
+bool SfxMedium::ShowLockFileProblemDialog(MessageDlg nWhichDlg)
+{
+    // system file locking is not active, ask user whether he wants to open the document without any locking
+    uno::Reference< task::XInteractionHandler > xHandler = GetInteractionHandler();
+
+    if (xHandler.is())
+    {
+        ::rtl::Reference< ::ucbhelper::InteractionRequest > xIgnoreRequestImpl;
+
+        switch (nWhichDlg)
+        {
+            case MessageDlg::LockFileIgnore:
+                xIgnoreRequestImpl = new ::ucbhelper::InteractionRequest(uno::Any( document::LockFileIgnoreRequest() ));
+                break;
+            case MessageDlg::LockFileCorrupt:
+                xIgnoreRequestImpl = new ::ucbhelper::InteractionRequest(uno::Any( document::LockFileCorruptRequest() ));
+                break;
+        }
+
+        uno::Sequence< uno::Reference< task::XInteractionContinuation > > aContinuations{
+            new ::ucbhelper::InteractionAbort(xIgnoreRequestImpl.get()),
+            new ::ucbhelper::InteractionApprove(xIgnoreRequestImpl.get())
+        };
+        xIgnoreRequestImpl->setContinuations(aContinuations);
+
+        xHandler->handle(xIgnoreRequestImpl);
+
+        ::rtl::Reference< ::ucbhelper::InteractionContinuation > xSelected = xIgnoreRequestImpl->getSelection();
+        bool bReadOnly = true;
+
+        if (uno::Reference<task::XInteractionAbort>(xSelected.get(), uno::UNO_QUERY).is())
+        {
+            SetError(ERRCODE_ABORT);
+            bReadOnly = false;
+        }
+        else if (!uno::Reference<task::XInteractionApprove>(xSelected.get(), uno::UNO_QUERY).is())
+        {
+            // user selected "Notify"
+            pImpl->m_bNotifyWhenEditable = true;
+            AddToCheckEditableWorkerList();
+        }
+
+        if (bReadOnly)
+            GetItemSet()->Put(SfxBoolItem(SID_DOC_READONLY, true));
+
+        return bReadOnly;
+    }
+
+    return false;
+}
+
+namespace
+{
+    bool isSuitableProtocolForLocking(const OUString & rLogicName)
+    {
+        INetURLObject aUrl( rLogicName );
+        INetProtocol eProt = aUrl.GetProtocol();
+#if !HAVE_FEATURE_MACOSX_SANDBOX
+        if (eProt == INetProtocol::File) {
+            return true;
+        }
+#endif
+        return eProt == INetProtocol::Smb || eProt == INetProtocol::Sftp;
+    }
+}
+
+#endif // HAVE_FEATURE_MULTIUSER_ENVIRONMENT
+
+// sets SID_DOC_READONLY if the document cannot be opened for editing
+// if user cancel the loading the ERROR_ABORT is set
+SfxMedium::LockFileResult SfxMedium::LockOrigFileOnDemand(bool bLoading, bool bNoUI,
+                                                          bool bTryIgnoreLockFile,
+                                                          LockFileEntry* pLockData)
+{
+#if !HAVE_FEATURE_MULTIUSER_ENVIRONMENT
+    (void) bLoading;
+    (void) bNoUI;
+    (void) bTryIgnoreLockFile;
+    (void) pLockData;
+    return LockFileResult::Succeeded;
+#else
+    LockFileResult eResult = LockFileResult::Failed;
+
+    // check if path scheme is http:// or https://
+    // may be this is better if used always, in Android and iOS as well?
+    // if this code should be always there, remember to move the relevant code in UnlockFile method as well !
+
+    if ( GetURLObject().isAnyKnownWebDAVScheme() )
+    {
+        // do nothing if WebDAV locking is disabled
+        if (!IsWebDAVLockingUsed())
+            return LockFileResult::Succeeded;
+
+        {
+            bool bResult = pImpl->m_bLocked;
+            bool bIsTemplate = false;
+            // so, this is webdav stuff...
+            if ( !bResult )
+            {
+                // no read-write access is necessary on loading if the document is explicitly opened as copy
+                const SfxBoolItem* pTemplateItem = SfxItemSet::GetItem<SfxBoolItem>(GetItemSet(), SID_TEMPLATE, false);
+                bIsTemplate = ( bLoading && pTemplateItem && pTemplateItem->GetValue() );
+            }
+
+            if ( !bIsTemplate && !bResult && !IsReadOnly() )
+            {
+                ShowLockResult bUIStatus = ShowLockResult::NoLock;
+                do
+                {
+                    if( !bResult )
+                    {
+                        uno::Reference< task::XInteractionHandler > xCHandler = GetInteractionHandler( true );
+                        Reference< css::ucb::XCommandEnvironment > xComEnv = new ::ucbhelper::CommandEnvironment(
+                            xCHandler, Reference< css::ucb::XProgressHandler >() );
+
+                        ucbhelper::Content aContentToLock(
+                            GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ),
+                            xComEnv, comphelper::getProcessComponentContext() );
+
+                        try
+                        {
+                            aContentToLock.lock();
+                            bResult = true;
+                        }
+                        catch ( ucb::InteractiveLockingLockedException& )
+                        {
+                            // received when the resource is already locked
+                            if (!bNoUI || pLockData)
+                            {
+                                // get the lock owner, using a special ucb.webdav property
+                                // the owner property retrieved here is  what the other principal send the server
+                                // when activating the lock.
+                                // See http://tools.ietf.org/html/rfc4918#section-14.17 for details
+                                LockFileEntry aLockData;
+                                aLockData[LockFileComponent::OOOUSERNAME] = "Unknown user";
+                                // This solution works right when the LO user name and the WebDAV user
+                                // name are the same.
+                                // A better thing to do would be to obtain the 'real' WebDAV user name,
+                                // but that's not possible from a WebDAV UCP provider client.
+                                LockFileEntry aOwnData = svt::LockFileCommon::GenerateOwnEntry();
+                                // use the current LO user name as the system name
+                                aLockData[LockFileComponent::SYSUSERNAME]
+                                    = aOwnData[LockFileComponent::SYSUSERNAME];
+
+                                uno::Sequence<css::ucb::Lock> aLocks;
+                                // getting the property, send a PROPFIND to the server over the net
+                                if ((aContentToLock.getPropertyValue("DAV:lockdiscovery") >>= aLocks) && aLocks.hasElements())
+                                {
+                                    // got at least a lock, show the owner of the first lock returned
+                                    css::ucb::Lock aLock = aLocks[0];
+                                    OUString aOwner;
+                                    if (aLock.Owner >>= aOwner)
+                                    {
+                                        // we need to display the WebDAV user name owning the lock, not the local one
+                                        aLockData[LockFileComponent::OOOUSERNAME] = aOwner;
+                                    }
+                                }
+
+                                if (!bNoUI)
+                                {
+                                    bUIStatus = ShowLockedDocumentDialog(aLockData, bLoading, false,
+                                                                         true);
+                                }
+
+                                if (pLockData)
+                                {
+                                    std::copy(aLockData.begin(), aLockData.end(), pLockData->begin());
+                                }
+                            }
+                        }
+                        catch( ucb::InteractiveNetworkWriteException& )
+                        {
+                            // This catch it's not really needed, here just for the sake of documentation on the behaviour.
+                            // This is the most likely reason:
+                            // - the remote site is a WebDAV with special configuration: read/only for read operations
+                            //   and read/write for write operations, the user is not allowed to lock/write and
+                            //   she cancelled the credentials request.
+                            //   this is not actually an error, but the exception is sent directly from ucb, avoiding the automatic
+                            //   management that takes part in cancelCommandExecution()
+                            // Unfortunately there is no InteractiveNetwork*Exception available to signal this more correctly
+                            // since it mostly happens on read/only part of webdav, this can be the most correct
+                            // exception available
+                        }
+                        catch( uno::Exception& )
+                        {
+                            TOOLS_WARN_EXCEPTION( "sfx.doc", "Locking exception: WebDAV while trying to lock the file" );
+                        }
+                    }
+                } while( !bResult && bUIStatus == ShowLockResult::Try );
+            }
+
+            pImpl->m_bLocked = bResult;
+
+            if ( !bResult && GetError() == ERRCODE_NONE )
+            {
+                // the error should be set in case it is storing process
+                // or the document has been opened for editing explicitly
+                const SfxBoolItem* pReadOnlyItem = SfxItemSet::GetItem<SfxBoolItem>(pImpl->m_pSet.get(), SID_DOC_READONLY, false);
+
+                if ( !bLoading || (pReadOnlyItem && !pReadOnlyItem->GetValue()) )
+                    SetError(ERRCODE_IO_ACCESSDENIED);
+                else
+                    GetItemSet()->Put( SfxBoolItem( SID_DOC_READONLY, true ) );
+            }
+
+            // when the file is locked, get the current file date
+            if ( bResult && DocNeedsFileDateCheck() )
+                GetInitFileDate( true );
+
+            if ( bResult )
+                eResult = LockFileResult::Succeeded;
+        }
+        return eResult;
+    }
+
+    if (!IsLockingUsed())
+        return LockFileResult::Succeeded;
+    if (GetURLObject().HasError())
+        return eResult;
+
+    try
+    {
+        if ( pImpl->m_bLocked && bLoading
+             && GetURLObject().GetProtocol() == INetProtocol::File )
+        {
+            // if the document is already locked the system locking might be temporarily off after storing
+            // check whether the system file locking should be taken again
+            GetLockingStream_Impl();
+        }
+
+        bool bResult = pImpl->m_bLocked;
+
+        if ( !bResult )
+        {
+            // no read-write access is necessary on loading if the document is explicitly opened as copy
+            const SfxBoolItem* pTemplateItem = SfxItemSet::GetItem<SfxBoolItem>(GetItemSet(), SID_TEMPLATE, false);
+            bResult = ( bLoading && pTemplateItem && pTemplateItem->GetValue() );
+        }
+
+        if ( !bResult && !IsReadOnly() )
+        {
+            bool bContentReadonly = false;
+            if ( bLoading && GetURLObject().GetProtocol() == INetProtocol::File )
+            {
+                // let the original document be opened to check the possibility to open it for editing
+                // and to let the writable stream stay open to hold the lock on the document
+                GetLockingStream_Impl();
+            }
+
+            // "IsReadOnly" property does not allow to detect whether the file is readonly always
+            // so we try always to open the file for editing
+            // the file is readonly only in case the read-write stream can not be opened
+            if ( bLoading && !pImpl->m_xLockingStream.is() )
+            {
+                try
+                {
+                    // MediaDescriptor does this check also, the duplication should be avoided in future
+                    Reference< css::ucb::XCommandEnvironment > xDummyEnv;
+                    ::ucbhelper::Content aContent( GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ), xDummyEnv, comphelper::getProcessComponentContext() );
+                    aContent.getPropertyValue("IsReadOnly") >>= bContentReadonly;
+                }
+                catch( const uno::Exception& ) {}
+            }
+
+            // do further checks only if the file not readonly in fs
+            if ( !bContentReadonly )
+            {
+                // the special file locking should be used only for suitable URLs
+                if ( isSuitableProtocolForLocking( pImpl->m_aLogicName ) )
+                {
+
+                    // in case of storing the document should request the output before locking
+                    if ( bLoading )
+                    {
+                        // let the stream be opened to check the system file locking
+                        GetMedium_Impl();
+                        if (GetError() != ERRCODE_NONE) {
+                            return eResult;
+                        }
+                    }
+
+                    ShowLockResult bUIStatus = ShowLockResult::NoLock;
+
+                    // check whether system file locking has been used, the default value is false
+                    bool bUseSystemLock = comphelper::isFileUrl( pImpl->m_aLogicName ) && IsSystemFileLockingUsed();
+
+                    // TODO/LATER: This implementation does not allow to detect the system lock on saving here, actually this is no big problem
+                    // if system lock is used the writeable stream should be available
+                    bool bHandleSysLocked = ( bLoading && bUseSystemLock && !pImpl->xStream.is() && !pImpl->m_pOutStream );
+
+                    // The file is attempted to get locked for the duration of lockfile creation on save
+                    std::unique_ptr<osl::File> pFileLock;
+                    if (!bLoading && bUseSystemLock && pImpl->pTempFile)
+                    {
+                        INetURLObject aDest(GetURLObject());
+                        OUString aDestURL(aDest.GetMainURL(INetURLObject::DecodeMechanism::NONE));
+
+                        if (comphelper::isFileUrl(aDestURL) || !aDest.removeSegment())
+                        {
+                            pFileLock = std::make_unique<osl::File>(aDestURL);
+                            auto rc = pFileLock->open(osl_File_OpenFlag_Write);
+                            if (rc == osl::FileBase::E_ACCES)
+                                bHandleSysLocked = true;
+                        }
+                    }
+
+                    do
+                    {
+                        try
+                        {
+                            ::svt::DocumentLockFile aLockFile( pImpl->m_aLogicName );
+
+                            std::unique_ptr<svt::MSODocumentLockFile> pMSOLockFile;
+                            const SvtFilterOptions& rOpt = SvtFilterOptions::Get();
+                            if (rOpt.IsMSOLockFileCreationIsEnabled() && svt::MSODocumentLockFile::IsMSOSupportedFileFormat(pImpl->m_aLogicName))
+                            {
+                                pMSOLockFile.reset(new svt::MSODocumentLockFile(pImpl->m_aLogicName));
+                                pImpl->m_bMSOLockFileCreated = true;
+                            }
+
+                            bool  bIoErr = false;
+
+                            if (!bHandleSysLocked)
+                            {
+                                try
+                                {
+                                    bResult = aLockFile.CreateOwnLockFile();
+                                    if(pMSOLockFile)
+                                        bResult &= pMSOLockFile->CreateOwnLockFile();
+                                }
+                                catch (const uno::Exception&)
+                                {
+                                    if (tools::IsMappedWebDAVPath(GetURLObject().GetMainURL(
+                                            INetURLObject::DecodeMechanism::NONE)))
+                                    {
+                                        // This is a path that redirects to a WebDAV resource;
+                                        // so failure creating lockfile is not an error here.
+                                        bResult = true;
+                                    }
+                                    else if (bLoading && !bNoUI)
+                                    {
+                                        bIoErr = true;
+                                        ShowLockFileProblemDialog(MessageDlg::LockFileIgnore);
+                                        bResult = true;   // always delete the defect lock-file
+                                    }
+                                }
+
+                                // in case OOo locking is turned off the lock file is still written if possible
+                                // but it is ignored while deciding whether the document should be opened for editing or not
+                                if (!bResult && !IsOOoLockFileUsed() && !bIoErr)
+                                {
+                                    bResult = true;
+                                    // take the ownership over the lock file
+                                    aLockFile.OverwriteOwnLockFile();
+
+                                    if(pMSOLockFile)
+                                        pMSOLockFile->OverwriteOwnLockFile();
+                                }
+                            }
+
+                            if ( !bResult )
+                            {
+                                LockFileEntry aData;
+                                try
+                                {
+                                    aData = aLockFile.GetLockData();
+                                }
+                                catch (const io::WrongFormatException&)
+                                {
+                                    // we get empty or corrupt data
+                                    // info to the user
+                                    if (!bIoErr && bLoading && !bNoUI )
+                                        bResult = ShowLockFileProblemDialog(MessageDlg::LockFileCorrupt);
+
+                                    // not show the Lock Document Dialog
+                                    bIoErr = true;
+                                }
+                                catch( const uno::Exception& )
+                                {
+                                    // show the Lock Document Dialog, when locked from other app
+                                    bIoErr = !bHandleSysLocked;
+                                }
+
+                                bool bOwnLock = false;
+
+                                if (!bHandleSysLocked)
+                                {
+                                    LockFileEntry aOwnData = svt::LockFileCommon::GenerateOwnEntry();
+                                    bOwnLock = aOwnData[LockFileComponent::SYSUSERNAME] == aData[LockFileComponent::SYSUSERNAME];
+
+                                    if (bOwnLock
+                                        && aOwnData[LockFileComponent::LOCALHOST] == aData[LockFileComponent::LOCALHOST]
+                                        && aOwnData[LockFileComponent::USERURL] == aData[LockFileComponent::USERURL])
+                                    {
+                                        // this is own lock from the same installation, it could remain because of crash
+                                        bResult = true;
+                                    }
+                                }
+
+                                if ( !bResult && !bIoErr)
+                                {
+                                    if (!bNoUI)
+                                        bUIStatus = ShowLockedDocumentDialog(
+                                            aData, bLoading, bOwnLock, bHandleSysLocked);
+                                    else if (bLoading && bTryIgnoreLockFile && !bHandleSysLocked)
+                                        bUIStatus = ShowLockResult::Succeeded;
+
+                                    if ( bUIStatus == ShowLockResult::Succeeded )
+                                    {
+                                        // take the ownership over the lock file
+                                        bResult = aLockFile.OverwriteOwnLockFile();
+
+                                        if(pMSOLockFile)
+                                            pMSOLockFile->OverwriteOwnLockFile();
+                                    }
+                                    else if (bLoading && !bHandleSysLocked)
+                                        eResult = LockFileResult::FailedLockFile;
+
+                                    if (!bResult && pLockData)
+                                    {
+                                        std::copy(aData.begin(), aData.end(), pLockData->begin());
+                                    }
+                                }
+                            }
+                        }
+                        catch( const uno::Exception& )
+                        {
+                        }
+                    } while( !bResult && bUIStatus == ShowLockResult::Try );
+
+                    pImpl->m_bLocked = bResult;
+                }
+                else
+                {
+                    // this is no file URL, check whether the file is readonly
+                    bResult = !bContentReadonly;
+                }
+            }
+            else // read-only
+            {
+                AddToCheckEditableWorkerList();
+            }
+        }
+
+        if ( !bResult && GetError() == ERRCODE_NONE )
+        {
+            // the error should be set in case it is storing process
+            // or the document has been opened for editing explicitly
+            const SfxBoolItem* pReadOnlyItem = SfxItemSet::GetItem<SfxBoolItem>(pImpl->m_pSet.get(), SID_DOC_READONLY, false);
+
+            if ( !bLoading || (pReadOnlyItem && !pReadOnlyItem->GetValue()) )
+                SetError(ERRCODE_IO_ACCESSDENIED);
+            else
+                GetItemSet()->Put( SfxBoolItem( SID_DOC_READONLY, true ) );
+        }
+
+        // when the file is locked, get the current file date
+        if ( bResult && DocNeedsFileDateCheck() )
+            GetInitFileDate( true );
+
+        if ( bResult )
+            eResult = LockFileResult::Succeeded;
+    }
+    catch( const uno::Exception& )
+    {
+        TOOLS_WARN_EXCEPTION( "sfx.doc", "Locking exception: high probability, that the content has not been created" );
+    }
+
+    return eResult;
+#endif
+}
+
+
+uno::Reference < embed::XStorage > SfxMedium::GetStorage( bool bCreateTempFile )
+{
+    if ( pImpl->xStorage.is() || pImpl->m_bTriedStorage )
+        return pImpl->xStorage;
+
+    uno::Sequence< uno::Any > aArgs( 2 );
+    auto pArgs = aArgs.getArray();
+
+    // the medium should be retrieved before temporary file creation
+    // to let the MediaDescriptor be filled with the streams
+    GetMedium_Impl();
+
+    if ( bCreateTempFile )
+        CreateTempFile( false );
+
+    GetMedium_Impl();
+
+    if ( GetError() )
+        return pImpl->xStorage;
+
+    const SfxBoolItem* pRepairItem = SfxItemSet::GetItem<SfxBoolItem>(GetItemSet(), SID_REPAIRPACKAGE, false);
+    if ( pRepairItem && pRepairItem->GetValue() )
+    {
+        // the storage should be created for repairing mode
+        CreateTempFile( false );
+        GetMedium_Impl();
+
+        Reference< css::ucb::XProgressHandler > xProgressHandler;
+        Reference< css::task::XStatusIndicator > xStatusIndicator;
+
+        const SfxUnoAnyItem* pxProgressItem = SfxItemSet::GetItem<SfxUnoAnyItem>(GetItemSet(), SID_PROGRESS_STATUSBAR_CONTROL, false);
+        if( pxProgressItem && ( pxProgressItem->GetValue() >>= xStatusIndicator ) )
+            xProgressHandler.set( new utl::ProgressHandlerWrap( xStatusIndicator ) );
+
+        uno::Sequence< beans::PropertyValue > aAddProps{
+            comphelper::makePropertyValue("RepairPackage", true),
+            comphelper::makePropertyValue("StatusIndicator", xProgressHandler)
+        };
+
+        // the first arguments will be filled later
+        aArgs.realloc( 3 );
+        pArgs = aArgs.getArray();
+        pArgs[2] <<= aAddProps;
+    }
+
+    if ( pImpl->xStream.is() )
+    {
+        // since the storage is based on temporary stream we open it always read-write
+        pArgs[0] <<= pImpl->xStream;
+        pArgs[1] <<= embed::ElementModes::READWRITE;
+        pImpl->bStorageBasedOnInStream = true;
+        if (pImpl->m_bDisableFileSync)
+        {
+            // Forward NoFileSync to the storage factory.
+            aArgs.realloc(3); // ??? this may re-write the data added above for pRepairItem
+            pArgs = aArgs.getArray();
+            uno::Sequence<beans::PropertyValue> aProperties(
+                comphelper::InitPropertySequence({ { "NoFileSync", uno::Any(true) } }));
+            pArgs[2] <<= aProperties;
+        }
+    }
+    else if ( pImpl->xInputStream.is() )
+    {
+        // since the storage is based on temporary stream we open it always read-write
+        pArgs[0] <<= pImpl->xInputStream;
+        pArgs[1] <<= embed::ElementModes::READ;
+        pImpl->bStorageBasedOnInStream = true;
+    }
+    else
+    {
+        CloseStreams_Impl();
+        pArgs[0] <<= pImpl->m_aName;
+        pArgs[1] <<= embed::ElementModes::READ;
+        pImpl->bStorageBasedOnInStream = false;
+    }
+
+    try
+    {
+        pImpl->xStorage.set( ::comphelper::OStorageHelper::GetStorageFactory()->createInstanceWithArguments( aArgs ),
+                            uno::UNO_QUERY );
+    }
+    catch( const uno::Exception& )
+    {
+        // impossibility to create the storage is no error
+    }
+
+    if( ( pImpl->nLastStorageError = GetError() ) != ERRCODE_NONE )
+    {
+        pImpl->xStorage = nullptr;
+        if ( pImpl->m_pInStream )
+            pImpl->m_pInStream->Seek(0);
+        return uno::Reference< embed::XStorage >();
+    }
+
+    pImpl->m_bTriedStorage = true;
+
+    // TODO/LATER: Get versionlist on demand
+    if ( pImpl->xStorage.is() )
+    {
+        SetEncryptionDataToStorage_Impl();
+        GetVersionList();
+    }
+
+    const SfxInt16Item* pVersion = SfxItemSet::GetItem<SfxInt16Item>(pImpl->m_pSet.get(), SID_VERSION, false);
+
+    bool bResetStorage = false;
+    if ( pVersion && pVersion->GetValue() )
+    {
+        // Read all available versions
+        if ( pImpl->aVersions.hasElements() )
+        {
+            // Search for the version fits the comment
+            // The versions are numbered starting with 1, versions with
+            // negative versions numbers are counted backwards from the
+            // current version
+            short nVersion = pVersion->GetValue();
+            if ( nVersion<0 )
+                nVersion = static_cast<short>(pImpl->aVersions.getLength()) + nVersion;
+            else // nVersion > 0; pVersion->GetValue() != 0 was the condition to this block
+                nVersion--;
+
+            const util::RevisionTag& rTag = pImpl->aVersions[nVersion];
+            {
+                // Open SubStorage for all versions
+                uno::Reference < embed::XStorage > xSub = pImpl->xStorage->openStorageElement( "Versions",
+                        embed::ElementModes::READ );
+
+                DBG_ASSERT( xSub.is(), "Version list, but no Versions!" );
+
+                // There the version is stored as packed Stream
+                uno::Reference < io::XStream > xStr = xSub->openStreamElement( rTag.Identifier, embed::ElementModes::READ );
+                std::unique_ptr<SvStream> pStream(utl::UcbStreamHelper::CreateStream( xStr ));
+                if ( pStream && pStream->GetError() == ERRCODE_NONE )
+                {
+                    // Unpack Stream  in TempDir
+                    ::utl::TempFile aTempFile;
+                    const OUString& aTmpName = aTempFile.GetURL();
+                    SvFileStream    aTmpStream( aTmpName, SFX_STREAM_READWRITE );
+
+                    pStream->ReadStream( aTmpStream );
+                    pStream.reset();
+                    aTmpStream.Close();
+
+                    // Open data as Storage
+                    pImpl->m_nStorOpenMode = SFX_STREAM_READONLY;
+                    pImpl->xStorage = comphelper::OStorageHelper::GetStorageFromURL( aTmpName, embed::ElementModes::READ );
+                    pImpl->bStorageBasedOnInStream = false;
+                    OUString aTemp;
+                    osl::FileBase::getSystemPathFromFileURL( aTmpName, aTemp );
+                    SetPhysicalName_Impl( aTemp );
+
+                    pImpl->bIsTemp = true;
+                    GetItemSet()->Put( SfxBoolItem( SID_DOC_READONLY, true ) );
+                    // TODO/MBA
+                    pImpl->aVersions.realloc(0);
+                }
+                else
+                    bResetStorage = true;
+            }
+        }
+        else
+            bResetStorage = true;
+    }
+
+    if ( bResetStorage )
+    {
+        pImpl->xStorage.clear();
+        if ( pImpl->m_pInStream )
+            pImpl->m_pInStream->Seek( 0 );
+    }
+
+    pImpl->bIsStorage = pImpl->xStorage.is();
+    return pImpl->xStorage;
+}
+
+
+uno::Reference< embed::XStorage > const & SfxMedium::GetZipStorageToSign_Impl( bool bReadOnly )
+{
+    if ( !GetError() && !pImpl->m_xZipStorage.is() )
+    {
+        GetMedium_Impl();
+
+        try
+        {
+            // we can not sign document if there is no stream
+            // should it be possible at all?
+            if ( !bReadOnly && pImpl->xStream.is() )
+            {
+                pImpl->m_xZipStorage = ::comphelper::OStorageHelper::GetStorageOfFormatFromStream( ZIP_STORAGE_FORMAT_STRING, pImpl->xStream );
+            }
+            else if ( pImpl->xInputStream.is() )
+            {
+                pImpl->m_xZipStorage = ::comphelper::OStorageHelper::GetStorageOfFormatFromInputStream( ZIP_STORAGE_FORMAT_STRING, pImpl->xInputStream );
+            }
+        }
+        catch( const uno::Exception& )
+        {
+            SAL_WARN( "sfx.doc", "No possibility to get readonly version of storage from medium!" );
+        }
+
+        if ( GetError() ) // do not remove warnings
+            ResetError();
+    }
+
+    return pImpl->m_xZipStorage;
+}
+
+
+void SfxMedium::CloseZipStorage_Impl()
+{
+    if ( pImpl->m_xZipStorage.is() )
+    {
+        try {
+            pImpl->m_xZipStorage->dispose();
+        } catch( const uno::Exception& )
+        {}
+
+        pImpl->m_xZipStorage.clear();
+    }
+}
+
+void SfxMedium::CloseStorage()
+{
+    if ( pImpl->xStorage.is() )
+    {
+        uno::Reference < lang::XComponent > xComp = pImpl->xStorage;
+        // in the salvage mode the medium does not own the storage
+        if ( pImpl->bDisposeStorage && !pImpl->m_bSalvageMode )
+        {
+            try {
+                xComp->dispose();
+            } catch( const uno::Exception& )
+            {
+                SAL_WARN( "sfx.doc", "Medium's storage is already disposed!" );
+            }
+        }
+
+        pImpl->xStorage.clear();
+        pImpl->bStorageBasedOnInStream = false;
+    }
+
+    pImpl->m_bTriedStorage = false;
+    pImpl->bIsStorage = false;
+}
+
+void SfxMedium::CanDisposeStorage_Impl( bool bDisposeStorage )
+{
+    pImpl->bDisposeStorage = bDisposeStorage;
+}
+
+bool SfxMedium::WillDisposeStorageOnClose_Impl()
+{
+    return pImpl->bDisposeStorage;
+}
+
+StreamMode SfxMedium::GetOpenMode() const
+{
+    return pImpl->m_nStorOpenMode;
+}
+
+void SfxMedium::SetOpenMode( StreamMode nStorOpen,
+                             bool bDontClose )
+{
+    if ( pImpl->m_nStorOpenMode != nStorOpen )
+    {
+        pImpl->m_nStorOpenMode = nStorOpen;
+
+        if( !bDontClose )
+        {
+            if ( pImpl->xStorage.is() )
+                CloseStorage();
+
+            CloseStreams_Impl();
+        }
+    }
+}
+
+
+bool SfxMedium::UseBackupToRestore_Impl( ::ucbhelper::Content& aOriginalContent,
+                                            const Reference< css::ucb::XCommandEnvironment >& xComEnv )
+{
+    try
+    {
+        ::ucbhelper::Content aTransactCont( pImpl->m_aBackupURL, xComEnv, comphelper::getProcessComponentContext() );
+
+        Reference< XInputStream > aOrigInput = aTransactCont.openStream();
+        aOriginalContent.writeStream( aOrigInput, true );
+        return true;
+    }
+    catch( const Exception& )
+    {
+        // in case of failure here the backup file should not be removed
+        // TODO/LATER: a message should be used to let user know about the backup
+        pImpl->m_bRemoveBackup = false;
+        // TODO/LATER: needs a specific error code
+        pImpl->m_eError = ERRCODE_IO_GENERAL;
+    }
+
+    return false;
+}
+
+
+bool SfxMedium::StorageCommit_Impl()
+{
+    bool bResult = false;
+    Reference< css::ucb::XCommandEnvironment > xDummyEnv;
+    ::ucbhelper::Content aOriginalContent;
+
+    if ( pImpl->xStorage.is() )
+    {
+        if ( !GetError() )
+        {
+            uno::Reference < embed::XTransactedObject > xTrans( pImpl->xStorage, uno::UNO_QUERY );
+            if ( xTrans.is() )
+            {
+                try
+                {
+                    xTrans->commit();
+                    CloseZipStorage_Impl();
+                    bResult = true;
+                }
+                catch ( const embed::UseBackupException& aBackupExc )
+                {
+                    // since the temporary file is created always now, the scenario is close to be impossible
+                    if ( !pImpl->pTempFile )
+                    {
+                        OSL_ENSURE( !pImpl->m_aBackupURL.isEmpty(), "No backup on storage commit!" );
+                        if ( !pImpl->m_aBackupURL.isEmpty()
+                            && ::ucbhelper::Content::create( GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ),
+                                                        xDummyEnv, comphelper::getProcessComponentContext(),
+                                                        aOriginalContent ) )
+                        {
+                            // use backup to restore the file
+                            // the storage has already disconnected from original location
+                            CloseAndReleaseStreams_Impl();
+                            if ( !UseBackupToRestore_Impl( aOriginalContent, xDummyEnv ) )
+                            {
+                                // connect the medium to the temporary file of the storage
+                                pImpl->aContent = ::ucbhelper::Content();
+                                pImpl->m_aName = aBackupExc.TemporaryFileURL;
+                                OSL_ENSURE( !pImpl->m_aName.isEmpty(), "The exception _must_ contain the temporary URL!" );
+                            }
+                        }
+                    }
+
+                    if (!GetError())
+                        SetError(ERRCODE_IO_GENERAL);
+                }
+                catch ( const uno::Exception& )
+                {
+                    //TODO/LATER: improve error handling
+                    SetError(ERRCODE_IO_GENERAL);
+                }
+            }
+        }
+    }
+
+    return bResult;
+}
+
+
+void SfxMedium::TransactedTransferForFS_Impl( const INetURLObject& aSource,
+                                                 const INetURLObject& aDest,
+                                                 const Reference< css::ucb::XCommandEnvironment >& xComEnv )
+{
+    Reference< css::ucb::XCommandEnvironment > xDummyEnv;
+    ::ucbhelper::Content aOriginalContent;
+
+    try
+    {
+        aOriginalContent = ::ucbhelper::Content( aDest.GetMainURL( INetURLObject::DecodeMechanism::NONE ), xComEnv, comphelper::getProcessComponentContext() );
+    }
+    catch ( const css::ucb::CommandAbortedException& )
+    {
+        pImpl->m_eError = ERRCODE_ABORT;
+    }
+    catch ( const css::ucb::CommandFailedException& )
+    {
+        pImpl->m_eError = ERRCODE_ABORT;
+    }
+    catch (const css::ucb::ContentCreationException& ex)
+    {
+        pImpl->m_eError = ERRCODE_IO_GENERAL;
+        if (
+            (ex.eError == css::ucb::ContentCreationError_NO_CONTENT_PROVIDER    ) ||
+            (ex.eError == css::ucb::ContentCreationError_CONTENT_CREATION_FAILED)
+           )
+        {
+            pImpl->m_eError = ERRCODE_IO_NOTEXISTSPATH;
+        }
+    }
+    catch (const css::uno::Exception&)
+    {
+       pImpl->m_eError = ERRCODE_IO_GENERAL;
+    }
+
+    if( pImpl->m_eError && !pImpl->m_eError.IsWarning() )
+        return;
+
+    if ( pImpl->xStorage.is() )
+        CloseStorage();
+
+    CloseStreams_Impl();
+
+    ::ucbhelper::Content aTempCont;
+    if( ::ucbhelper::Content::create( aSource.GetMainURL( INetURLObject::DecodeMechanism::NONE ), xDummyEnv, comphelper::getProcessComponentContext(), aTempCont ) )
+    {
+        bool bTransactStarted = false;
+        const SfxBoolItem* pOverWrite = SfxItemSet::GetItem<SfxBoolItem>(GetItemSet(), SID_OVERWRITE, false);
+        bool bOverWrite = !pOverWrite || pOverWrite->GetValue();
+        bool bResult = false;
+
+        try
+        {
+            // tdf#60237 - if the OverWrite property of the MediaDescriptor is set to false,
+            // try to write the file before trying to rename or copy it
+            if (!(bOverWrite
+                  && ::utl::UCBContentHelper::IsDocument(
+                      aDest.GetMainURL(INetURLObject::DecodeMechanism::NONE))))
+            {
+                Reference< XInputStream > aTempInput = aTempCont.openStream();
+                aOriginalContent.writeStream( aTempInput, bOverWrite );
+                bResult = true;
+            } else {
+                OUString aSourceMainURL = aSource.GetMainURL(INetURLObject::DecodeMechanism::NONE);
+                OUString aDestMainURL = aDest.GetMainURL(INetURLObject::DecodeMechanism::NONE);
+
+                sal_uInt64 nAttributes = GetDefaultFileAttributes(aDestMainURL);
+                if (IsFileMovable(aDest)
+                    && osl::File::replace(aSourceMainURL, aDestMainURL) == osl::FileBase::E_None)
+                {
+                    if (nAttributes)
+                        // Adjust attributes, source might be created with
+                        // the osl_File_OpenFlag_Private flag.
+                        osl::File::setAttributes(aDestMainURL, nAttributes);
+                    bResult = true;
+                }
+                else
+                {
+                    if( pImpl->m_aBackupURL.isEmpty() )
+                        DoInternalBackup_Impl( aOriginalContent );
+
+                    if( !pImpl->m_aBackupURL.isEmpty() )
+                    {
+                        Reference< XInputStream > aTempInput = aTempCont.openStream();
+                        bTransactStarted = true;
+                        aOriginalContent.setPropertyValue( "Size", uno::Any( sal_Int64(0) ) );
+                        aOriginalContent.writeStream( aTempInput, bOverWrite );
+                        bResult = true;
+                    }
+                    else
+                    {
+                        pImpl->m_eError = ERRCODE_SFX_CANTCREATEBACKUP;
+                    }
+                }
+            }
+        }
+        catch ( const css::ucb::CommandAbortedException& )
+        {
+            pImpl->m_eError = ERRCODE_ABORT;
+        }
+        catch ( const css::ucb::CommandFailedException& )
+        {
+            pImpl->m_eError = ERRCODE_ABORT;
+        }
+        catch ( const css::ucb::InteractiveIOException& r )
+        {
+            if ( r.Code == IOErrorCode_ACCESS_DENIED )
+                pImpl->m_eError = ERRCODE_IO_ACCESSDENIED;
+            else if ( r.Code == IOErrorCode_NOT_EXISTING )
+                pImpl->m_eError = ERRCODE_IO_NOTEXISTS;
+            else if ( r.Code == IOErrorCode_CANT_READ )
+                pImpl->m_eError = ERRCODE_IO_CANTREAD;
+            else
+                pImpl->m_eError = ERRCODE_IO_GENERAL;
+        }
+        // tdf#60237 - if the file is already present, raise the appropriate error
+        catch (const css::ucb::NameClashException& )
+        {
+            pImpl->m_eError = ERRCODE_IO_ALREADYEXISTS;
+        }
+        catch ( const css::uno::Exception& )
+        {
+            pImpl->m_eError = ERRCODE_IO_GENERAL;
+        }
+
+        if ( bResult )
+        {
+            if ( pImpl->pTempFile )
+            {
+                pImpl->pTempFile->EnableKillingFile();
+                pImpl->pTempFile.reset();
+            }
+        }
+        else if ( bTransactStarted )
+        {
+            UseBackupToRestore_Impl( aOriginalContent, xDummyEnv );
+        }
+    }
+    else
+        pImpl->m_eError = ERRCODE_IO_CANTREAD;
+}
+
+
+bool SfxMedium::TryDirectTransfer( const OUString& aURL, SfxItemSet const & aTargetSet )
+{
+    if ( GetError() )
+        return false;
+
+    // if the document had no password it should be stored without password
+    // if the document had password it should be stored with the same password
+    // otherwise the stream copying can not be done
+    const SfxStringItem* pNewPassItem = aTargetSet.GetItem<SfxStringItem>(SID_PASSWORD, false);
+    const SfxStringItem* pOldPassItem = SfxItemSet::GetItem<SfxStringItem>(GetItemSet(), SID_PASSWORD, false);
+    if ( ( !pNewPassItem && !pOldPassItem )
+      || ( pNewPassItem && pOldPassItem && pNewPassItem->GetValue() == pOldPassItem->GetValue() ) )
+    {
+        // the filter must be the same
+        const SfxStringItem* pNewFilterItem = aTargetSet.GetItem<SfxStringItem>(SID_FILTER_NAME, false);
+        const SfxStringItem* pOldFilterItem = SfxItemSet::GetItem<SfxStringItem>(GetItemSet(), SID_FILTER_NAME, false);
+        if ( pNewFilterItem && pOldFilterItem && pNewFilterItem->GetValue() == pOldFilterItem->GetValue() )
+        {
+            // get the input stream and copy it
+            // in case of success return true
+            uno::Reference< io::XInputStream > xInStream = GetInputStream();
+
+            ResetError();
+            if ( xInStream.is() )
+            {
+                try
+                {
+                    uno::Reference< io::XSeekable > xSeek( xInStream, uno::UNO_QUERY );
+                    sal_Int64 nPos = 0;
+                    if ( xSeek.is() )
+                    {
+                        nPos = xSeek->getPosition();
+                        xSeek->seek( 0 );
+                    }
+
+                    uno::Reference < css::ucb::XCommandEnvironment > xEnv;
+                    ::ucbhelper::Content aTargetContent( aURL, xEnv, comphelper::getProcessComponentContext() );
+
+                    InsertCommandArgument aInsertArg;
+                    aInsertArg.Data = xInStream;
+                    const SfxBoolItem* pOverWrite = aTargetSet.GetItem<SfxBoolItem>(SID_OVERWRITE, false);
+                    if ( pOverWrite && !pOverWrite->GetValue() ) // argument says: never overwrite
+                        aInsertArg.ReplaceExisting = false;
+                    else
+                        aInsertArg.ReplaceExisting = true; // default is overwrite existing files
+
+                    Any aCmdArg;
+                    aCmdArg <<= aInsertArg;
+                    aTargetContent.executeCommand( "insert",
+                                                    aCmdArg );
+
+                    if ( xSeek.is() )
+                        xSeek->seek( nPos );
+
+                    return true;
+                }
+                catch( const uno::Exception& )
+                {}
+            }
+        }
+    }
+
+    return false;
+}
+
+
+void SfxMedium::Transfer_Impl()
+{
+    // The transfer is required only in two cases: either if there is a temporary file or if there is a salvage item
+    OUString aNameURL;
+    if ( pImpl->pTempFile )
+        aNameURL = pImpl->pTempFile->GetURL();
+    else if ( !pImpl->m_aLogicName.isEmpty() && pImpl->m_bSalvageMode )
+    {
+        // makes sense only in case logic name is set
+        if ( osl::FileBase::getFileURLFromSystemPath( pImpl->m_aName, aNameURL )
+             != osl::FileBase::E_None )
+            SAL_WARN( "sfx.doc", "The medium name is not convertible!" );
+    }
+
+    if ( aNameURL.isEmpty() || ( pImpl->m_eError && !pImpl->m_eError.IsWarning() ) )
+        return;
+
+    SAL_INFO( "sfx.doc", "SfxMedium::Transfer_Impl, copying to target" );
+
+    Reference < css::ucb::XCommandEnvironment > xEnv;
+    Reference< XOutputStream > rOutStream;
+
+    // in case an output stream is provided from outside and the URL is correct
+    // commit to the stream
+    if (pImpl->m_aLogicName.startsWith("private:stream"))
+    {
+        // TODO/LATER: support storing to SID_STREAM
+        const SfxUnoAnyItem* pOutStreamItem = SfxItemSet::GetItem<SfxUnoAnyItem>(pImpl->m_pSet.get(), SID_OUTPUTSTREAM, false);
+        if( pOutStreamItem && ( pOutStreamItem->GetValue() >>= rOutStream ) )
+        {
+            if ( pImpl->xStorage.is() )
+                CloseStorage();
+
+            CloseStreams_Impl();
+
+            INetURLObject aSource( aNameURL );
+            ::ucbhelper::Content aTempCont;
+            if( ::ucbhelper::Content::create( aSource.GetMainURL( INetURLObject::DecodeMechanism::NONE ), xEnv, comphelper::getProcessComponentContext(), aTempCont ) )
+            {
+                try
+                {
+                    sal_Int32 nRead;
+                    sal_Int32 nBufferSize = 32767;
+                    Sequence < sal_Int8 > aSequence ( nBufferSize );
+                    Reference< XInputStream > aTempInput = aTempCont.openStream();
+
+                    do
+                    {
+                        nRead = aTempInput->readBytes ( aSequence, nBufferSize );
+                        if ( nRead < nBufferSize )
+                        {
+                            Sequence < sal_Int8 > aTempBuf ( aSequence.getConstArray(), nRead );
+                            rOutStream->writeBytes ( aTempBuf );
+                        }
+                        else
+                            rOutStream->writeBytes ( aSequence );
+                    }
+                    while ( nRead == nBufferSize );
+
+                    // remove temporary file
+                    if ( pImpl->pTempFile )
+                    {
+                        pImpl->pTempFile->EnableKillingFile();
+                        pImpl->pTempFile.reset();
+                    }
+                }
+                catch( const Exception& )
+                {}
+            }
+        }
+        else
+        {
+            SAL_WARN( "sfx.doc", "Illegal Output stream parameter!" );
+            SetError(ERRCODE_IO_GENERAL);
+        }
+
+        // free the reference
+        if ( pImpl->m_pSet )
+            pImpl->m_pSet->ClearItem( SID_OUTPUTSTREAM );
+
+        return;
+    }
+
+    GetContent();
+    if ( !pImpl->aContent.get().is() )
+    {
+        pImpl->m_eError = ERRCODE_IO_NOTEXISTS;
+        return;
+    }
+
+    INetURLObject aDest( GetURLObject() );
+
+    // source is the temp file written so far
+    INetURLObject aSource( aNameURL );
+
+    // a special case, an interaction handler should be used for
+    // authentication in case it is available
+    Reference< css::ucb::XCommandEnvironment > xComEnv;
+    bool bForceInteractionHandler = GetURLObject().isAnyKnownWebDAVScheme();
+    Reference< css::task::XInteractionHandler > xInteractionHandler = GetInteractionHandler(bForceInteractionHandler);
+    if (xInteractionHandler.is())
+        xComEnv = new ::ucbhelper::CommandEnvironment( xInteractionHandler,
+                                                  Reference< css::ucb::XProgressHandler >() );
+
+    OUString aDestURL( aDest.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
+
+    if ( comphelper::isFileUrl( aDestURL ) || !aDest.removeSegment() )
+    {
+        TransactedTransferForFS_Impl( aSource, aDest, xComEnv );
+
+        if (!pImpl->m_bDisableFileSync)
+        {
+            // Hideous - no clean way to do this, so we re-open the file just to fsync it
+            osl::File aFile( aDestURL );
+            if ( aFile.open( osl_File_OpenFlag_Write ) == osl::FileBase::E_None )
+            {
+                aFile.sync();
+                SAL_INFO( "sfx.doc", "fsync'd saved file '" << aDestURL << "'" );
+                aFile.close();
+            }
+        }
+    }
+    else
+    {
+        // create content for the parent folder and call transfer on that content with the source content
+        // and the destination file name as parameters
+        ::ucbhelper::Content aSourceContent;
+        ::ucbhelper::Content aTransferContent;
+
+        ::ucbhelper::Content aDestContent;
+        (void)::ucbhelper::Content::create( aDestURL, xComEnv, comphelper::getProcessComponentContext(), aDestContent );
+        // For checkin, we need the object URL, not the parent folder:
+        if ( !IsInCheckIn( ) )
+        {
+            // Get the parent URL from the XChild if possible: why would the URL necessarily have
+            // a hierarchical path? It's not always the case for CMIS.
+            Reference< css::container::XChild> xChild( aDestContent.get(), uno::UNO_QUERY );
+            OUString sParentUrl;
+            if ( xChild.is( ) )
+            {
+                Reference< css::ucb::XContent > xParent( xChild->getParent( ), uno::UNO_QUERY );
+                if ( xParent.is( ) )
+                {
+                    sParentUrl = xParent->getIdentifier( )->getContentIdentifier();
+                }
+            }
+
+            if ( sParentUrl.isEmpty() )
+                aDestURL = aDest.GetMainURL( INetURLObject::DecodeMechanism::NONE );
+                    // adjust to above aDest.removeSegment()
+            else
+                aDestURL = sParentUrl;
+        }
+
+        // LongName wasn't defined anywhere, only used here... get the Title instead
+        // as it's less probably empty
+        OUString aFileName;
+        Any aAny = aDestContent.getPropertyValue("Title");
+        aAny >>= aFileName;
+        aAny = aDestContent.getPropertyValue( "ObjectId" );
+        OUString sObjectId;
+        aAny >>= sObjectId;
+        if ( aFileName.isEmpty() )
+            aFileName = GetURLObject().getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset );
+
+        try
+        {
+            aTransferContent = ::ucbhelper::Content( aDestURL, xComEnv, comphelper::getProcessComponentContext() );
+        }
+        catch (const css::ucb::ContentCreationException& ex)
+        {
+            pImpl->m_eError = ERRCODE_IO_GENERAL;
+            if (
+                (ex.eError == css::ucb::ContentCreationError_NO_CONTENT_PROVIDER    ) ||
+                (ex.eError == css::ucb::ContentCreationError_CONTENT_CREATION_FAILED)
+               )
+            {
+                pImpl->m_eError = ERRCODE_IO_NOTEXISTSPATH;
+            }
+        }
+        catch (const css::uno::Exception&)
+        {
+            pImpl->m_eError = ERRCODE_IO_GENERAL;
+        }
+
+        if ( !pImpl->m_eError || pImpl->m_eError.IsWarning() )
+        {
+            // free resources, otherwise the transfer may fail
+            if ( pImpl->xStorage.is() )
+                CloseStorage();
+
+            CloseStreams_Impl();
+
+            (void)::ucbhelper::Content::create( aSource.GetMainURL( INetURLObject::DecodeMechanism::NONE ), xEnv, comphelper::getProcessComponentContext(), aSourceContent );
+
+            // check for external parameters that may customize the handling of NameClash situations
+            const SfxBoolItem* pOverWrite = SfxItemSet::GetItem<SfxBoolItem>(GetItemSet(), SID_OVERWRITE, false);
+            sal_Int32 nNameClash;
+            if ( pOverWrite && !pOverWrite->GetValue() )
+                // argument says: never overwrite
+                nNameClash = NameClash::ERROR;
+            else
+                // default is overwrite existing files
+                nNameClash = NameClash::OVERWRITE;
+
+            try
+            {
+                OUString aMimeType = pImpl->getFilterMimeType();
+                ::ucbhelper::InsertOperation eOperation = ::ucbhelper::InsertOperation::Copy;
+                bool bMajor = false;
+                OUString sComment;
+                if ( IsInCheckIn( ) )
+                {
+                    eOperation = ::ucbhelper::InsertOperation::Checkin;
+                    const SfxBoolItem* pMajor = SfxItemSet::GetItem<SfxBoolItem>(GetItemSet(), SID_DOCINFO_MAJOR, false);
+                    bMajor = pMajor && pMajor->GetValue( );
+                    const SfxStringItem* pComments = SfxItemSet::GetItem<SfxStringItem>(GetItemSet(), SID_DOCINFO_COMMENTS, false);
+                    if ( pComments )
+                        sComment = pComments->GetValue( );
+                }
+                OUString sResultURL;
+                aTransferContent.transferContent(
+                    aSourceContent, eOperation,
+                    aFileName, nNameClash, aMimeType, bMajor, sComment,
+                    &sResultURL, sObjectId );
+
+                if ( !sResultURL.isEmpty( ) )  // Likely to happen only for checkin
+                    SwitchDocumentToFile( sResultURL );
+                try
+                {
+                    if ( GetURLObject().isAnyKnownWebDAVScheme() &&
+                         eOperation == ::ucbhelper::InsertOperation::Copy )
+                    {
+                        // tdf#95272 try to re-issue a lock command when a new file is created.
+                        // This may be needed because some WebDAV servers fail to implement the
+                        // 'LOCK on unallocated reference', see issue comment:
+                        // <https://bugs.documentfoundation.org/show_bug.cgi?id=95792#c8>
+                        // and specification at:
+                        // <http://tools.ietf.org/html/rfc4918#section-7.3>
+                        // If the WebDAV resource is already locked by this LO instance, nothing will
+                        // happen, e.g. the LOCK method will not be sent to the server.
+                        ::ucbhelper::Content aLockContent( GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ), xComEnv, comphelper::getProcessComponentContext() );
+                        aLockContent.lock();
+                    }
+                }
+                catch ( css::uno::Exception & )
+                {
+                    TOOLS_WARN_EXCEPTION( "sfx.doc", "LOCK not working while re-issuing it" );
+                }
+            }
+            catch ( const css::ucb::CommandAbortedException& )
+            {
+                pImpl->m_eError = ERRCODE_ABORT;
+            }
+            catch ( const css::ucb::CommandFailedException& )
+            {
+                pImpl->m_eError = ERRCODE_ABORT;
+            }
+            catch ( const css::ucb::InteractiveIOException& r )
+            {
+                if ( r.Code == IOErrorCode_ACCESS_DENIED )
+                    pImpl->m_eError = ERRCODE_IO_ACCESSDENIED;
+                else if ( r.Code == IOErrorCode_NOT_EXISTING )
+                    pImpl->m_eError = ERRCODE_IO_NOTEXISTS;
+                else if ( r.Code == IOErrorCode_CANT_READ )
+                    pImpl->m_eError = ERRCODE_IO_CANTREAD;
+                else
+                    pImpl->m_eError = ERRCODE_IO_GENERAL;
+            }
+            catch ( const css::uno::Exception& )
+            {
+                pImpl->m_eError = ERRCODE_IO_GENERAL;
+            }
+
+            // do not switch from temporary file in case of nonfile protocol
+        }
+    }
+
+    if ( ( !pImpl->m_eError || pImpl->m_eError.IsWarning() ) && !pImpl->pTempFile )
+    {
+        // without a TempFile the physical and logical name should be the same after successful transfer
+        if (osl::FileBase::getSystemPathFromFileURL(
+              GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ), pImpl->m_aName )
+            != osl::FileBase::E_None)
+        {
+            pImpl->m_aName.clear();
+        }
+        pImpl->m_bSalvageMode = false;
+    }
+}
+
+
+void SfxMedium::DoInternalBackup_Impl( const ::ucbhelper::Content& aOriginalContent,
+                                       std::u16string_view aPrefix,
+                                       const OUString& aExtension,
+                                       const OUString& aDestDir )
+{
+    if ( !pImpl->m_aBackupURL.isEmpty() )
+        return; // the backup was done already
+
+    ::utl::TempFile aTransactTemp( aPrefix, true, &aExtension, &aDestDir );
+
+    INetURLObject aBackObj( aTransactTemp.GetURL() );
+    OUString aBackupName = aBackObj.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset );
+
+    Reference < css::ucb::XCommandEnvironment > xDummyEnv;
+    ::ucbhelper::Content aBackupCont;
+    if( ::ucbhelper::Content::create( aDestDir, xDummyEnv, comphelper::getProcessComponentContext(), aBackupCont ) )
+    {
+        try
+        {
+            OUString sMimeType = pImpl->getFilterMimeType();
+            aBackupCont.transferContent( aOriginalContent,
+                                            ::ucbhelper::InsertOperation::Copy,
+                                            aBackupName,
+                                            NameClash::OVERWRITE,
+                                            sMimeType );
+            pImpl->m_aBackupURL = aBackObj.GetMainURL( INetURLObject::DecodeMechanism::NONE );
+            pImpl->m_bRemoveBackup = true;
+        }
+        catch( const Exception& )
+        {}
+    }
+
+    if ( pImpl->m_aBackupURL.isEmpty() )
+        aTransactTemp.EnableKillingFile();
+}
+
+
+void SfxMedium::DoInternalBackup_Impl( const ::ucbhelper::Content& aOriginalContent )
+{
+    if ( !pImpl->m_aBackupURL.isEmpty() )
+        return; // the backup was done already
+
+    OUString aFileName =  GetURLObject().getName( INetURLObject::LAST_SEGMENT,
+                                                        true,
+                                                        INetURLObject::DecodeMechanism::NONE );
+
+    sal_Int32 nPrefixLen = aFileName.lastIndexOf( '.' );
+    OUString aPrefix = ( nPrefixLen == -1 ) ? aFileName : aFileName.copy( 0, nPrefixLen );
+    OUString aExtension = ( nPrefixLen == -1 ) ? OUString() : aFileName.copy( nPrefixLen );
+    OUString aBakDir = SvtPathOptions().GetBackupPath();
+
+    // create content for the parent folder ( = backup folder )
+    ::ucbhelper::Content  aContent;
+    Reference < css::ucb::XCommandEnvironment > xEnv;
+    if( ::utl::UCBContentHelper::ensureFolder(comphelper::getProcessComponentContext(), xEnv, aBakDir, aContent) )
+        DoInternalBackup_Impl( aOriginalContent, aPrefix, aExtension, aBakDir );
+
+    if ( !pImpl->m_aBackupURL.isEmpty() )
+        return;
+
+    // the copying to the backup catalog failed ( for example because
+    // of using an encrypted partition as target catalog )
+    // since the user did not specify to make backup explicitly
+    // office should try to make backup in another place,
+    // target catalog does not look bad for this case ( and looks
+    // to be the only way for encrypted partitions )
+
+    INetURLObject aDest = GetURLObject();
+    if ( aDest.removeSegment() )
+        DoInternalBackup_Impl( aOriginalContent, aPrefix, aExtension, aDest.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
+}
+
+
+void SfxMedium::DoBackup_Impl()
+{
+    // source file name is the logical name of this medium
+    INetURLObject aSource( GetURLObject() );
+
+    // there is nothing to backup in case source file does not exist
+    if ( !::utl::UCBContentHelper::IsDocument( aSource.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ) )
+        return;
+
+    bool        bSuccess = false;
+
+    // get path for backups
+    OUString aBakDir = SvtPathOptions().GetBackupPath();
+    if( !aBakDir.isEmpty() )
+    {
+        // create content for the parent folder ( = backup folder )
+        ::ucbhelper::Content  aContent;
+        Reference < css::ucb::XCommandEnvironment > xEnv;
+        if( ::utl::UCBContentHelper::ensureFolder(comphelper::getProcessComponentContext(), xEnv, aBakDir, aContent) )
+        {
+            // save as ".bak" file
+            INetURLObject aDest( aBakDir );
+            aDest.insertName( aSource.getName() );
+            aDest.setExtension( u"bak" );
+            OUString aFileName = aDest.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset );
+
+            // create a content for the source file
+            ::ucbhelper::Content aSourceContent;
+            if ( ::ucbhelper::Content::create( aSource.GetMainURL( INetURLObject::DecodeMechanism::NONE ), xEnv, comphelper::getProcessComponentContext(), aSourceContent ) )
+            {
+                try
+                {
+                    // do the transfer ( copy source file to backup dir )
+                    OUString sMimeType = pImpl->getFilterMimeType();
+                    aContent.transferContent( aSourceContent,
+                                                        ::ucbhelper::InsertOperation::Copy,
+                                                        aFileName,
+                                                        NameClash::OVERWRITE,
+                                                        sMimeType );
+                    pImpl->m_aBackupURL = aDest.GetMainURL( INetURLObject::DecodeMechanism::NONE );
+                    pImpl->m_bRemoveBackup = false;
+                    bSuccess = true;
+                }
+                catch ( const css::uno::Exception& )
+                {
+                }
+            }
+        }
+    }
+
+    if ( !bSuccess )
+    {
+        pImpl->m_eError = ERRCODE_SFX_CANTCREATEBACKUP;
+    }
+}
+
+
+void SfxMedium::ClearBackup_Impl()
+{
+    if( pImpl->m_bRemoveBackup )
+    {
+        // currently a document is always stored in a new medium,
+        // thus if a backup can not be removed the backup URL should not be cleaned
+        if ( !pImpl->m_aBackupURL.isEmpty() )
+        {
+            if ( ::utl::UCBContentHelper::Kill( pImpl->m_aBackupURL ) )
+            {
+                pImpl->m_bRemoveBackup = false;
+                pImpl->m_aBackupURL.clear();
+            }
+            else
+            {
+
+                SAL_WARN( "sfx.doc", "Couldn't remove backup file!");
+            }
+        }
+    }
+    else
+        pImpl->m_aBackupURL.clear();
+}
+
+
+void SfxMedium::GetLockingStream_Impl()
+{
+    if ( GetURLObject().GetProtocol() != INetProtocol::File
+         || pImpl->m_xLockingStream.is() )
+        return;
+
+    const SfxUnoAnyItem* pWriteStreamItem = SfxItemSet::GetItem<SfxUnoAnyItem>(pImpl->m_pSet.get(), SID_STREAM, false);
+    if ( pWriteStreamItem )
+        pWriteStreamItem->GetValue() >>= pImpl->m_xLockingStream;
+
+    if ( pImpl->m_xLockingStream.is() )
+        return;
+
+    // open the original document
+    uno::Sequence< beans::PropertyValue > xProps;
+    TransformItems( SID_OPENDOC, *GetItemSet(), xProps );
+    utl::MediaDescriptor aMedium( xProps );
+
+    aMedium.addInputStreamOwnLock();
+
+    uno::Reference< io::XInputStream > xInputStream;
+    aMedium[utl::MediaDescriptor::PROP_STREAM] >>= pImpl->m_xLockingStream;
+    aMedium[utl::MediaDescriptor::PROP_INPUTSTREAM] >>= xInputStream;
+
+    if ( !pImpl->pTempFile && pImpl->m_aName.isEmpty() )
+    {
+        // the medium is still based on the original file, it makes sense to initialize the streams
+        if ( pImpl->m_xLockingStream.is() )
+            pImpl->xStream = pImpl->m_xLockingStream;
+
+        if ( xInputStream.is() )
+            pImpl->xInputStream = xInputStream;
+
+        if ( !pImpl->xInputStream.is() && pImpl->xStream.is() )
+            pImpl->xInputStream = pImpl->xStream->getInputStream();
+    }
+}
+
+
+void SfxMedium::GetMedium_Impl()
+{
+    if ( pImpl->m_pInStream
+        && (!pImpl->bIsTemp || pImpl->xInputStream.is() || pImpl->m_xInputStreamToLoadFrom.is() || pImpl->xStream.is() || pImpl->m_xLockingStream.is() ) )
+        return;
+
+    pImpl->bDownloadDone = false;
+    Reference< css::task::XInteractionHandler > xInteractionHandler = GetInteractionHandler();
+
+    //TODO/MBA: need support for SID_STREAM
+    const SfxUnoAnyItem* pWriteStreamItem = SfxItemSet::GetItem<SfxUnoAnyItem>(pImpl->m_pSet.get(), SID_STREAM, false);
+    const SfxUnoAnyItem* pInStreamItem = SfxItemSet::GetItem<SfxUnoAnyItem>(pImpl->m_pSet.get(), SID_INPUTSTREAM, false);
+    if ( pWriteStreamItem )
+    {
+        pWriteStreamItem->GetValue() >>= pImpl->xStream;
+
+        if ( pInStreamItem )
+            pInStreamItem->GetValue() >>= pImpl->xInputStream;
+
+        if ( !pImpl->xInputStream.is() && pImpl->xStream.is() )
+            pImpl->xInputStream = pImpl->xStream->getInputStream();
+    }
+    else if ( pInStreamItem )
+    {
+        pInStreamItem->GetValue() >>= pImpl->xInputStream;
+    }
+    else
+    {
+        uno::Sequence < beans::PropertyValue > xProps;
+        OUString aFileName;
+        if (!pImpl->m_aName.isEmpty())
+        {
+            if ( osl::FileBase::getFileURLFromSystemPath( pImpl->m_aName, aFileName )
+                 != osl::FileBase::E_None )
+            {
+                SAL_WARN( "sfx.doc", "Physical name not convertible!");
+            }
+        }
+        else
+            aFileName = GetName();
+
+        // in case the temporary file exists the streams should be initialized from it,
+        // but the original MediaDescriptor should not be changed
+        bool bFromTempFile = ( pImpl->pTempFile != nullptr );
+
+        if ( !bFromTempFile )
+        {
+            GetItemSet()->Put( SfxStringItem( SID_FILE_NAME, aFileName ) );
+            if( !(pImpl->m_nStorOpenMode & StreamMode::WRITE) )
+                GetItemSet()->Put( SfxBoolItem( SID_DOC_READONLY, true ) );
+            if (xInteractionHandler.is())
+                GetItemSet()->Put( SfxUnoAnyItem( SID_INTERACTIONHANDLER, Any(xInteractionHandler) ) );
+        }
+
+        if ( pImpl->m_xInputStreamToLoadFrom.is() )
+        {
+            pImpl->xInputStream = pImpl->m_xInputStreamToLoadFrom;
+            if (pImpl->m_bInputStreamIsReadOnly)
+                GetItemSet()->Put( SfxBoolItem( SID_DOC_READONLY, true ) );
+        }
+        else
+        {
+            TransformItems( SID_OPENDOC, *GetItemSet(), xProps );
+            utl::MediaDescriptor aMedium( xProps );
+
+            if ( pImpl->m_xLockingStream.is() && !bFromTempFile )
+            {
+                // the medium is not based on the temporary file, so the original stream can be used
+                pImpl->xStream = pImpl->m_xLockingStream;
+            }
+            else
+            {
+                if ( bFromTempFile )
+                {
+                    aMedium[utl::MediaDescriptor::PROP_URL] <<= aFileName;
+                    aMedium.erase( utl::MediaDescriptor::PROP_READONLY );
+                    aMedium.addInputStream();
+                }
+                else if ( GetURLObject().GetProtocol() == INetProtocol::File )
+                {
+                    // use the special locking approach only for file URLs
+                    aMedium.addInputStreamOwnLock();
+                }
+                else
+                {
+                    // add a check for protocol, if it's http or https or provide webdav then add
+                    // the interaction handler to be used by the authentication dialog
+                    if ( GetURLObject().isAnyKnownWebDAVScheme() )
+                    {
+                        aMedium[utl::MediaDescriptor::PROP_AUTHENTICATIONHANDLER] <<= GetInteractionHandler( true );
+                    }
+                    aMedium.addInputStream();
+                }
+                // the ReadOnly property set in aMedium is ignored
+                // the check is done in LockOrigFileOnDemand() for file and non-file URLs
+
+                //TODO/MBA: what happens if property is not there?!
+                aMedium[utl::MediaDescriptor::PROP_STREAM] >>= pImpl->xStream;
+                aMedium[utl::MediaDescriptor::PROP_INPUTSTREAM] >>= pImpl->xInputStream;
+            }
+
+            GetContent();
+            if ( !pImpl->xInputStream.is() && pImpl->xStream.is() )
+                pImpl->xInputStream = pImpl->xStream->getInputStream();
+        }
+
+        if ( !bFromTempFile )
+        {
+            //TODO/MBA: need support for SID_STREAM
+            if ( pImpl->xStream.is() )
+                GetItemSet()->Put( SfxUnoAnyItem( SID_STREAM, Any( pImpl->xStream ) ) );
+
+            GetItemSet()->Put( SfxUnoAnyItem( SID_INPUTSTREAM, Any( pImpl->xInputStream ) ) );
+        }
+    }
+
+    //TODO/MBA: ErrorHandling - how to transport error from MediaDescriptor
+    if ( !GetError() && !pImpl->xStream.is() && !pImpl->xInputStream.is() )
+        SetError(ERRCODE_IO_ACCESSDENIED);
+
+    if ( !GetError() && !pImpl->m_pInStream )
+    {
+        if ( pImpl->xStream.is() )
+            pImpl->m_pInStream = utl::UcbStreamHelper::CreateStream( pImpl->xStream );
+        else if ( pImpl->xInputStream.is() )
+            pImpl->m_pInStream = utl::UcbStreamHelper::CreateStream( pImpl->xInputStream );
+    }
+
+    pImpl->bDownloadDone = true;
+    pImpl->aDoneLink.ClearPendingCall();
+    ErrCode nError = GetError();
+    pImpl->aDoneLink.Call( reinterpret_cast<void*>(sal_uInt32(nError)) );
+}
+
+bool SfxMedium::IsRemote() const
+{
+    return pImpl->m_bRemote;
+}
+
+void SfxMedium::SetUpdatePickList(bool bVal)
+{
+    pImpl->bUpdatePickList = bVal;
+}
+
+bool SfxMedium::IsUpdatePickList() const
+{
+    return pImpl->bUpdatePickList;
+}
+
+void SfxMedium::SetLongName(const OUString &rName)
+{
+    pImpl->m_aLongName = rName;
+}
+
+const OUString& SfxMedium::GetLongName() const
+{
+    return pImpl->m_aLongName;
+}
+
+void SfxMedium::SetDoneLink( const Link<void*,void>& rLink )
+{
+    pImpl->aDoneLink = rLink;
+}
+
+void SfxMedium::Download( const Link<void*,void>& aLink )
+{
+    SetDoneLink( aLink );
+    GetInStream();
+    if ( pImpl->m_pInStream && !aLink.IsSet() )
+    {
+        while( !pImpl->bDownloadDone && !Application::IsQuit())
+            Application::Yield();
+    }
+}
+
+
+void SfxMedium::Init_Impl()
+/*  [Description]
+    Includes a valid:: sun:: com:: star:: util:: URL (If a file name was
+    previously in there) in the logical name and if available sets the
+    physical name as the file name.
+ */
+
+{
+    Reference< XOutputStream > rOutStream;
+
+    // TODO/LATER: handle lifetime of storages
+    pImpl->bDisposeStorage = false;
+
+    const SfxStringItem* pSalvageItem = SfxItemSet::GetItem<SfxStringItem>(pImpl->m_pSet.get(), SID_DOC_SALVAGE, false);
+    if ( pSalvageItem && pSalvageItem->GetValue().isEmpty() )
+    {
+        pSalvageItem = nullptr;
+        pImpl->m_pSet->ClearItem( SID_DOC_SALVAGE );
+    }
+
+    if (!pImpl->m_aLogicName.isEmpty())
+    {
+        INetURLObject aUrl( pImpl->m_aLogicName );
+        INetProtocol eProt = aUrl.GetProtocol();
+        if ( eProt == INetProtocol::NotValid )
+        {
+            SAL_WARN( "sfx.doc", "URL <" << pImpl->m_aLogicName << "> with unknown protocol" );
+        }
+        else
+        {
+            if ( aUrl.HasMark() )
+            {
+                std::unique_lock<std::recursive_mutex> chkEditLock;
+                if (pImpl->m_pCheckEditableWorkerMutex != nullptr)
+                    chkEditLock = std::unique_lock<std::recursive_mutex>(
+                        *(pImpl->m_pCheckEditableWorkerMutex));
+                pImpl->m_aLogicName = aUrl.GetURLNoMark( INetURLObject::DecodeMechanism::NONE );
+                if (chkEditLock.owns_lock())
+                    chkEditLock.unlock();
+                GetItemSet()->Put( SfxStringItem( SID_JUMPMARK, aUrl.GetMark() ) );
+            }
+
+            // try to convert the URL into a physical name - but never change a physical name
+            // physical name may be set if the logical name is changed after construction
+            if ( pImpl->m_aName.isEmpty() )
+                osl::FileBase::getSystemPathFromFileURL( GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ), pImpl->m_aName );
+            else
+            {
+                DBG_ASSERT( pSalvageItem, "Suspicious change of logical name!" );
+            }
+        }
+    }
+
+    if ( pSalvageItem && !pSalvageItem->GetValue().isEmpty() )
+    {
+        std::unique_lock<std::recursive_mutex> chkEditLock;
+        if (pImpl->m_pCheckEditableWorkerMutex != nullptr)
+            chkEditLock
+                = std::unique_lock<std::recursive_mutex>(*(pImpl->m_pCheckEditableWorkerMutex));
+        pImpl->m_aLogicName = pSalvageItem->GetValue();
+        pImpl->m_pURLObj.reset();
+        if (chkEditLock.owns_lock())
+            chkEditLock.unlock();
+        pImpl->m_bSalvageMode = true;
+    }
+
+    // in case output stream is by mistake here
+    // clear the reference
+    const SfxUnoAnyItem* pOutStreamItem = SfxItemSet::GetItem<SfxUnoAnyItem>(pImpl->m_pSet.get(), SID_OUTPUTSTREAM, false);
+    if( pOutStreamItem
+     && ( !( pOutStreamItem->GetValue() >>= rOutStream )
+          || !pImpl->m_aLogicName.startsWith("private:stream")) )
+    {
+        pImpl->m_pSet->ClearItem( SID_OUTPUTSTREAM );
+        SAL_WARN( "sfx.doc", "Unexpected Output stream parameter!" );
+    }
+
+    if (!pImpl->m_aLogicName.isEmpty())
+    {
+        // if the logic name is set it should be set in MediaDescriptor as well
+        const SfxStringItem* pFileNameItem = SfxItemSet::GetItem<SfxStringItem>(pImpl->m_pSet.get(), SID_FILE_NAME, false);
+        if ( !pFileNameItem )
+        {
+            // let the ItemSet be created if necessary
+            GetItemSet()->Put(
+                SfxStringItem(
+                    SID_FILE_NAME, INetURLObject( pImpl->m_aLogicName ).GetMainURL( INetURLObject::DecodeMechanism::NONE ) ) );
+        }
+    }
+
+    SetIsRemote_Impl();
+
+    osl::DirectoryItem item;
+    if (osl::DirectoryItem::get(GetName(), item) == osl::FileBase::E_None) {
+        osl::FileStatus stat(osl_FileStatus_Mask_Attributes);
+        if (item.getFileStatus(stat) == osl::FileBase::E_None
+            && stat.isValid(osl_FileStatus_Mask_Attributes))
+        {
+            if ((stat.getAttributes() & osl_File_Attribute_ReadOnly) != 0)
+            {
+                pImpl->m_bOriginallyReadOnly = true;
+            }
+        }
+    }
+}
+
+
+SfxMedium::SfxMedium() : pImpl(new SfxMedium_Impl)
+{
+    Init_Impl();
+}
+
+
+void SfxMedium::UseInteractionHandler( bool bUse )
+{
+    pImpl->bAllowDefaultIntHdl = bUse;
+}
+
+
+css::uno::Reference< css::task::XInteractionHandler >
+SfxMedium::GetInteractionHandler( bool bGetAlways )
+{
+    // if interaction isn't allowed explicitly ... return empty reference!
+    if ( !bGetAlways && !pImpl->bUseInteractionHandler )
+        return css::uno::Reference< css::task::XInteractionHandler >();
+
+    // search a possible existing handler inside cached item set
+    if ( pImpl->m_pSet )
+    {
+        css::uno::Reference< css::task::XInteractionHandler > xHandler;
+        const SfxUnoAnyItem* pHandler = SfxItemSet::GetItem<SfxUnoAnyItem>(pImpl->m_pSet.get(), SID_INTERACTIONHANDLER, false);
+        if ( pHandler && (pHandler->GetValue() >>= xHandler) && xHandler.is() )
+            return xHandler;
+    }
+
+    // if default interaction isn't allowed explicitly ... return empty reference!
+    if ( !bGetAlways && !pImpl->bAllowDefaultIntHdl )
+        return css::uno::Reference< css::task::XInteractionHandler >();
+
+    // otherwise return cached default handler ... if it exist.
+    if ( pImpl->xInteraction.is() )
+        return pImpl->xInteraction;
+
+    // create default handler and cache it!
+    Reference< uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext();
+    pImpl->xInteraction.set(
+        task::InteractionHandler::createWithParent(xContext, nullptr), UNO_QUERY_THROW );
+    return pImpl->xInteraction;
+}
+
+void SfxMedium::SetFilter( const std::shared_ptr<const SfxFilter>& pFilter )
+{
+    pImpl->m_pFilter = pFilter;
+}
+
+const std::shared_ptr<const SfxFilter>& SfxMedium::GetFilter() const
+{
+    return pImpl->m_pFilter;
+}
+
+sal_uInt32 SfxMedium::CreatePasswordToModifyHash( std::u16string_view aPasswd, bool bWriter )
+{
+    sal_uInt32 nHash = 0;
+
+    if ( !aPasswd.empty() )
+    {
+        if ( bWriter )
+        {
+            nHash = ::comphelper::DocPasswordHelper::GetWordHashAsUINT32( aPasswd );
+        }
+        else
+        {
+            rtl_TextEncoding nEncoding = osl_getThreadTextEncoding();
+            nHash = ::comphelper::DocPasswordHelper::GetXLHashAsUINT16( aPasswd, nEncoding );
+        }
+    }
+
+    return nHash;
+}
+
+
+void SfxMedium::Close(bool bInDestruction)
+{
+    if ( pImpl->xStorage.is() )
+    {
+        CloseStorage();
+    }
+
+    CloseStreams_Impl(bInDestruction);
+
+    UnlockFile( false );
+}
+
+void SfxMedium::CloseAndRelease()
+{
+    if ( pImpl->xStorage.is() )
+    {
+        CloseStorage();
+    }
+
+    CloseAndReleaseStreams_Impl();
+
+    UnlockFile( true );
+}
+
+void SfxMedium::DisableUnlockWebDAV( bool bDisableUnlockWebDAV )
+{
+    pImpl->m_bDisableUnlockWebDAV = bDisableUnlockWebDAV;
+}
+
+void SfxMedium::DisableFileSync(bool bDisableFileSync)
+{
+    pImpl->m_bDisableFileSync = bDisableFileSync;
+}
+
+void SfxMedium::UnlockFile( bool bReleaseLockStream )
+{
+#if !HAVE_FEATURE_MULTIUSER_ENVIRONMENT
+    (void) bReleaseLockStream;
+#else
+    // check if webdav
+    if ( GetURLObject().isAnyKnownWebDAVScheme() )
+    {
+        // do nothing if WebDAV locking if disabled
+        // (shouldn't happen because we already skipped locking,
+        // see LockOrigFileOnDemand, but just in case ...)
+        if (!IsWebDAVLockingUsed())
+            return;
+
+        if ( pImpl->m_bLocked )
+        {
+            // an interaction handler should be used for authentication, if needed
+            try {
+                uno::Reference< css::task::XInteractionHandler > xHandler = GetInteractionHandler( true );
+                uno::Reference< css::ucb::XCommandEnvironment > xComEnv = new ::ucbhelper::CommandEnvironment( xHandler,
+                                                               Reference< css::ucb::XProgressHandler >() );
+                ucbhelper::Content aContentToUnlock( GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ), xComEnv, comphelper::getProcessComponentContext());
+                pImpl->m_bLocked = false;
+                //check if WebDAV unlock was explicitly disabled
+                if ( !pImpl->m_bDisableUnlockWebDAV )
+                    aContentToUnlock.unlock();
+            }
+            catch ( uno::Exception& )
+            {
+                TOOLS_WARN_EXCEPTION( "sfx.doc", "Locking exception: WebDAV while trying to lock the file" );
+            }
+        }
+        return;
+    }
+
+    if ( pImpl->m_xLockingStream.is() )
+    {
+        if ( bReleaseLockStream )
+        {
+            try
+            {
+                uno::Reference< io::XInputStream > xInStream = pImpl->m_xLockingStream->getInputStream();
+                uno::Reference< io::XOutputStream > xOutStream = pImpl->m_xLockingStream->getOutputStream();
+                if ( xInStream.is() )
+                    xInStream->closeInput();
+                if ( xOutStream.is() )
+                    xOutStream->closeOutput();
+            }
+            catch( const uno::Exception& )
+            {}
+        }
+
+        pImpl->m_xLockingStream.clear();
+    }
+
+    if ( !pImpl->m_bLocked )
+        return;
+
+    ::svt::DocumentLockFile aLockFile( pImpl->m_aLogicName );
+
+    try
+    {
+        pImpl->m_bLocked = false;
+        // TODO/LATER: A warning could be shown in case the file is not the own one
+        aLockFile.RemoveFile();
+    }
+    catch( const io::WrongFormatException& )
+    {
+        try
+        {
+            // erase the empty or corrupt file
+            aLockFile.RemoveFileDirectly();
+        }
+        catch( const uno::Exception& )
+        {}
+    }
+    catch( const uno::Exception& )
+    {}
+
+    if(!pImpl->m_bMSOLockFileCreated)
+        return;
+
+    ::svt::MSODocumentLockFile aMSOLockFile( pImpl->m_aLogicName );
+
+    try
+    {
+        pImpl->m_bLocked = false;
+        // TODO/LATER: A warning could be shown in case the file is not the own one
+        aMSOLockFile.RemoveFile();
+    }
+    catch( const io::WrongFormatException& )
+    {
+        try
+        {
+            // erase the empty or corrupt file
+            aMSOLockFile.RemoveFileDirectly();
+        }
+        catch( const uno::Exception& )
+        {}
+    }
+    catch( const uno::Exception& )
+    {}
+    pImpl->m_bMSOLockFileCreated = false;
+#endif
+}
+
+void SfxMedium::CloseAndReleaseStreams_Impl()
+{
+    CloseZipStorage_Impl();
+
+    uno::Reference< io::XInputStream > xInToClose = pImpl->xInputStream;
+    uno::Reference< io::XOutputStream > xOutToClose;
+    if ( pImpl->xStream.is() )
+    {
+        xOutToClose = pImpl->xStream->getOutputStream();
+
+        // if the locking stream is closed here the related member should be cleaned
+        if ( pImpl->xStream == pImpl->m_xLockingStream )
+            pImpl->m_xLockingStream.clear();
+    }
+
+    // The probably existing SvStream wrappers should be closed first
+    CloseStreams_Impl();
+
+    // in case of salvage mode the storage is based on the streams
+    if ( pImpl->m_bSalvageMode )
+        return;
+
+    try
+    {
+        if ( xInToClose.is() )
+            xInToClose->closeInput();
+        if ( xOutToClose.is() )
+            xOutToClose->closeOutput();
+    }
+    catch ( const uno::Exception& )
+    {
+    }
+}
+
+
+void SfxMedium::CloseStreams_Impl(bool bInDestruction)
+{
+    CloseInStream_Impl(bInDestruction);
+    CloseOutStream_Impl();
+
+    if ( pImpl->m_pSet )
+        pImpl->m_pSet->ClearItem( SID_CONTENT );
+
+    pImpl->aContent = ::ucbhelper::Content();
+}
+
+
+void SfxMedium::SetIsRemote_Impl()
+{
+    INetURLObject aObj( GetName() );
+    switch( aObj.GetProtocol() )
+    {
+        case INetProtocol::Ftp:
+        case INetProtocol::Http:
+        case INetProtocol::Https:
+            pImpl->m_bRemote = true;
+        break;
+        default:
+            pImpl->m_bRemote = GetName().startsWith("private:msgid");
+            break;
+    }
+
+    // As files that are written to the remote transmission must also be able
+    // to be read.
+    if (pImpl->m_bRemote)
+        pImpl->m_nStorOpenMode |= StreamMode::READ;
+}
+
+
+void SfxMedium::SetName( const OUString& aNameP, bool bSetOrigURL )
+{
+    if (pImpl->aOrigURL.isEmpty())
+        pImpl->aOrigURL = pImpl->m_aLogicName;
+    if( bSetOrigURL )
+        pImpl->aOrigURL = aNameP;
+    std::unique_lock<std::recursive_mutex> chkEditLock;
+    if (pImpl->m_pCheckEditableWorkerMutex != nullptr)
+        chkEditLock = std::unique_lock<std::recursive_mutex>(*(pImpl->m_pCheckEditableWorkerMutex));
+    pImpl->m_aLogicName = aNameP;
+    pImpl->m_pURLObj.reset();
+    if (chkEditLock.owns_lock())
+        chkEditLock.unlock();
+    pImpl->aContent = ::ucbhelper::Content();
+    Init_Impl();
+}
+
+
+const OUString& SfxMedium::GetOrigURL() const
+{
+    return pImpl->aOrigURL.isEmpty() ? pImpl->m_aLogicName : pImpl->aOrigURL;
+}
+
+
+void SfxMedium::SetPhysicalName_Impl( const OUString& rNameP )
+{
+    if ( rNameP != pImpl->m_aName )
+    {
+        pImpl->pTempFile.reset();
+
+        if ( !pImpl->m_aName.isEmpty() || !rNameP.isEmpty() )
+            pImpl->aContent = ::ucbhelper::Content();
+
+        pImpl->m_aName = rNameP;
+        pImpl->m_bTriedStorage = false;
+        pImpl->bIsStorage = false;
+    }
+}
+
+void SfxMedium::ReOpen()
+{
+    bool bUseInteractionHandler = pImpl->bUseInteractionHandler;
+    pImpl->bUseInteractionHandler = false;
+    GetMedium_Impl();
+    pImpl->bUseInteractionHandler = bUseInteractionHandler;
+}
+
+void SfxMedium::CompleteReOpen()
+{
+    // do not use temporary file for reopen and in case of success throw the temporary file away
+    bool bUseInteractionHandler = pImpl->bUseInteractionHandler;
+    pImpl->bUseInteractionHandler = false;
+
+    std::unique_ptr<::utl::TempFile> pTmpFile;
+    if ( pImpl->pTempFile )
+    {
+        pTmpFile = std::move(pImpl->pTempFile);
+        pImpl->m_aName.clear();
+    }
+
+    GetMedium_Impl();
+
+    if ( GetError() )
+    {
+        if ( pImpl->pTempFile )
+        {
+            pImpl->pTempFile->EnableKillingFile();
+            pImpl->pTempFile.reset();
+        }
+        pImpl->pTempFile = std::move( pTmpFile );
+        if ( pImpl->pTempFile )
+            pImpl->m_aName = pImpl->pTempFile->GetFileName();
+    }
+    else if (pTmpFile)
+    {
+        pTmpFile->EnableKillingFile();
+        pTmpFile.reset();
+    }
+
+    pImpl->bUseInteractionHandler = bUseInteractionHandler;
+}
+
+SfxMedium::SfxMedium(const OUString &rName, StreamMode nOpenMode, std::shared_ptr<const SfxFilter> pFilter, const std::shared_ptr<SfxItemSet>& pInSet) :
+    pImpl(new SfxMedium_Impl)
+{
+    pImpl->m_pSet = pInSet;
+    pImpl->m_pFilter = std::move(pFilter);
+    pImpl->m_aLogicName = rName;
+    pImpl->m_nStorOpenMode = nOpenMode;
+    Init_Impl();
+}
+
+SfxMedium::SfxMedium(const OUString &rName, const OUString &rReferer, StreamMode nOpenMode, std::shared_ptr<const SfxFilter> pFilter, const std::shared_ptr<SfxItemSet>& pInSet) :
+    pImpl(new SfxMedium_Impl)
+{
+    pImpl->m_pSet = pInSet;
+    SfxItemSet * s = GetItemSet();
+    if (s->GetItem(SID_REFERER) == nullptr) {
+        s->Put(SfxStringItem(SID_REFERER, rReferer));
+    }
+    pImpl->m_pFilter = std::move(pFilter);
+    pImpl->m_aLogicName = rName;
+    pImpl->m_nStorOpenMode = nOpenMode;
+    Init_Impl();
+}
+
+SfxMedium::SfxMedium( const uno::Sequence<beans::PropertyValue>& aArgs ) :
+    pImpl(new SfxMedium_Impl)
+{
+    SfxAllItemSet *pParams = new SfxAllItemSet( SfxGetpApp()->GetPool() );
+    pImpl->m_pSet.reset( pParams );
+    TransformParameters( SID_OPENDOC, aArgs, *pParams );
+    SetArgs(aArgs);
+
+    OUString aFilterProvider, aFilterName;
+    {
+        const SfxStringItem* pItem = nullptr;
+        if ((pItem = pImpl->m_pSet->GetItemIfSet(SID_FILTER_PROVIDER)))
+            aFilterProvider = pItem->GetValue();
+
+        if ((pItem = pImpl->m_pSet->GetItemIfSet(SID_FILTER_NAME)))
+            aFilterName = pItem->GetValue();
+    }
+
+    if (aFilterProvider.isEmpty())
+    {
+        // This is a conventional filter type.
+        pImpl->m_pFilter = SfxGetpApp()->GetFilterMatcher().GetFilter4FilterName( aFilterName );
+    }
+    else
+    {
+        // This filter is from an external provider such as orcus.
+        pImpl->m_pCustomFilter = std::make_shared<SfxFilter>(aFilterProvider, aFilterName);
+        pImpl->m_pFilter = pImpl->m_pCustomFilter;
+    }
+
+    const SfxStringItem* pSalvageItem = SfxItemSet::GetItem<SfxStringItem>(pImpl->m_pSet.get(), SID_DOC_SALVAGE, false);
+    if( pSalvageItem )
+    {
+        // QUESTION: there is some treatment of Salvage in Init_Impl; align!
+        if ( !pSalvageItem->GetValue().isEmpty() )
+        {
+            // if a URL is provided in SalvageItem that means that the FileName refers to a temporary file
+            // that must be copied here
+
+            const SfxStringItem* pFileNameItem = SfxItemSet::GetItem<SfxStringItem>(pImpl->m_pSet.get(), SID_FILE_NAME, false);
+            if (!pFileNameItem) throw uno::RuntimeException();
+            OUString aNewTempFileURL = SfxMedium::CreateTempCopyWithExt( pFileNameItem->GetValue() );
+            if ( !aNewTempFileURL.isEmpty() )
+            {
+                pImpl->m_pSet->Put( SfxStringItem( SID_FILE_NAME, aNewTempFileURL ) );
+                pImpl->m_pSet->ClearItem( SID_INPUTSTREAM );
+                pImpl->m_pSet->ClearItem( SID_STREAM );
+                pImpl->m_pSet->ClearItem( SID_CONTENT );
+            }
+            else
+            {
+                SAL_WARN( "sfx.doc", "Can not create a new temporary file for crash recovery!" );
+            }
+        }
+    }
+
+    const SfxBoolItem* pReadOnlyItem = SfxItemSet::GetItem<SfxBoolItem>(pImpl->m_pSet.get(), SID_DOC_READONLY, false);
+    if ( pReadOnlyItem && pReadOnlyItem->GetValue() )
+        pImpl->m_bOriginallyLoadedReadOnly = true;
+
+    const SfxStringItem* pFileNameItem = SfxItemSet::GetItem<SfxStringItem>(pImpl->m_pSet.get(), SID_FILE_NAME, false);
+    if (!pFileNameItem) throw uno::RuntimeException();
+    pImpl->m_aLogicName = pFileNameItem->GetValue();
+    pImpl->m_nStorOpenMode = pImpl->m_bOriginallyLoadedReadOnly
+        ? SFX_STREAM_READONLY : SFX_STREAM_READWRITE;
+    Init_Impl();
+}
+
+void SfxMedium::SetArgs(const uno::Sequence<beans::PropertyValue>& rArgs)
+{
+    static constexpr OUStringLiteral sStream(u"Stream");
+    static constexpr OUStringLiteral sInputStream(u"InputStream");
+    comphelper::SequenceAsHashMap aArgsMap(rArgs);
+    aArgsMap.erase(sStream);
+    aArgsMap.erase(sInputStream);
+    pImpl->m_aArgs = aArgsMap.getAsConstPropertyValueList();
+}
+
+const uno::Sequence<beans::PropertyValue> & SfxMedium::GetArgs() const { return pImpl->m_aArgs; }
+
+SfxMedium::SfxMedium( const uno::Reference < embed::XStorage >& rStor, const OUString& rBaseURL, const std::shared_ptr<SfxItemSet>& p ) :
+    pImpl(new SfxMedium_Impl)
+{
+    OUString aType = SfxFilter::GetTypeFromStorage(rStor);
+    pImpl->m_pFilter = SfxGetpApp()->GetFilterMatcher().GetFilter4EA( aType );
+    DBG_ASSERT( pImpl->m_pFilter, "No Filter for storage found!" );
+
+    Init_Impl();
+    pImpl->xStorage = rStor;
+    pImpl->bDisposeStorage = false;
+
+    // always take BaseURL first, could be overwritten by ItemSet
+    GetItemSet()->Put( SfxStringItem( SID_DOC_BASEURL, rBaseURL ) );
+    if ( p )
+        GetItemSet()->Put( *p );
+}
+
+
+SfxMedium::SfxMedium( const uno::Reference < embed::XStorage >& rStor, const OUString& rBaseURL, const OUString &rTypeName, const std::shared_ptr<SfxItemSet>& p ) :
+    pImpl(new SfxMedium_Impl)
+{
+    pImpl->m_pFilter = SfxGetpApp()->GetFilterMatcher().GetFilter4EA( rTypeName );
+    DBG_ASSERT( pImpl->m_pFilter, "No Filter for storage found!" );
+
+    Init_Impl();
+    pImpl->xStorage = rStor;
+    pImpl->bDisposeStorage = false;
+
+    // always take BaseURL first, could be overwritten by ItemSet
+    GetItemSet()->Put( SfxStringItem( SID_DOC_BASEURL, rBaseURL ) );
+    if ( p )
+        GetItemSet()->Put( *p );
+}
+
+// NOTE: should only be called on main thread
+SfxMedium::~SfxMedium()
+{
+    CancelCheckEditableEntry();
+
+    // if there is a requirement to clean the backup this is the last possibility to do it
+    ClearBackup_Impl();
+
+    Close(/*bInDestruction*/true);
+
+    if( !pImpl->bIsTemp || pImpl->m_aName.isEmpty() )
+        return;
+
+    OUString aTemp;
+    if ( osl::FileBase::getFileURLFromSystemPath( pImpl->m_aName, aTemp )
+         != osl::FileBase::E_None )
+    {
+        SAL_WARN( "sfx.doc", "Physical name not convertible!");
+    }
+
+    if ( !::utl::UCBContentHelper::Kill( aTemp ) )
+    {
+        SAL_WARN( "sfx.doc", "Couldn't remove temporary file!");
+    }
+}
+
+const OUString& SfxMedium::GetName() const
+{
+    return pImpl->m_aLogicName;
+}
+
+const INetURLObject& SfxMedium::GetURLObject() const
+{
+    std::unique_lock<std::recursive_mutex> chkEditLock;
+    if (pImpl->m_pCheckEditableWorkerMutex != nullptr)
+        chkEditLock = std::unique_lock<std::recursive_mutex>(*(pImpl->m_pCheckEditableWorkerMutex));
+
+    if (!pImpl->m_pURLObj)
+    {
+        pImpl->m_pURLObj.reset( new INetURLObject( pImpl->m_aLogicName ) );
+        pImpl->m_pURLObj->SetMark(u"");
+    }
+
+    return *pImpl->m_pURLObj;
+}
+
+void SfxMedium::SetExpired_Impl( const DateTime& rDateTime )
+{
+    pImpl->aExpireTime = rDateTime;
+}
+
+
+bool SfxMedium::IsExpired() const
+{
+    return pImpl->aExpireTime.IsValidAndGregorian() && pImpl->aExpireTime < DateTime( DateTime::SYSTEM );
+}
+
+
+SfxFrame* SfxMedium::GetLoadTargetFrame() const
+{
+    return pImpl->wLoadTargetFrame;
+}
+
+void SfxMedium::setStreamToLoadFrom(const css::uno::Reference<css::io::XInputStream>& xInputStream, bool bIsReadOnly )
+{
+    pImpl->m_xInputStreamToLoadFrom = xInputStream;
+    pImpl->m_bInputStreamIsReadOnly = bIsReadOnly;
+}
+
+void SfxMedium::SetLoadTargetFrame(SfxFrame* pFrame )
+{
+    pImpl->wLoadTargetFrame = pFrame;
+}
+
+
+void SfxMedium::SetStorage_Impl( const uno::Reference < embed::XStorage >& rStor )
+{
+    pImpl->xStorage = rStor;
+}
+
+
+SfxItemSet* SfxMedium::GetItemSet() const
+{
+    // this method *must* return an ItemSet, returning NULL can cause crashes
+    if (!pImpl->m_pSet)
+        pImpl->m_pSet = std::make_shared<SfxAllItemSet>( SfxGetpApp()->GetPool() );
+    return pImpl->m_pSet.get();
+}
+
+
+SvKeyValueIterator* SfxMedium::GetHeaderAttributes_Impl()
+{
+    if( !pImpl->xAttributes.is() )
+    {
+        pImpl->xAttributes = SvKeyValueIteratorRef( new SvKeyValueIterator );
+
+        if ( GetContent().is() )
+        {
+            try
+            {
+                Any aAny = pImpl->aContent.getPropertyValue("MediaType");
+                OUString aContentType;
+                aAny >>= aContentType;
+
+                pImpl->xAttributes->Append( SvKeyValue( "content-type", aContentType ) );
+            }
+            catch ( const css::uno::Exception& )
+            {
+            }
+        }
+    }
+
+    return pImpl->xAttributes.get();
+}
+
+css::uno::Reference< css::io::XInputStream > const &  SfxMedium::GetInputStream()
+{
+    if ( !pImpl->xInputStream.is() )
+        GetMedium_Impl();
+    return pImpl->xInputStream;
+}
+
+const uno::Sequence < util::RevisionTag >& SfxMedium::GetVersionList( bool _bNoReload )
+{
+    // if the medium has no name, then this medium should represent a new document and can have no version info
+    if ( ( !_bNoReload || !pImpl->m_bVersionsAlreadyLoaded ) && !pImpl->aVersions.hasElements() &&
+         ( !pImpl->m_aName.isEmpty() || !pImpl->m_aLogicName.isEmpty() ) && GetStorage().is() )
+    {
+        uno::Reference < document::XDocumentRevisionListPersistence > xReader =
+                document::DocumentRevisionListPersistence::create( comphelper::getProcessComponentContext() );
+        try
+        {
+            pImpl->aVersions = xReader->load( GetStorage() );
+        }
+        catch ( const uno::Exception& )
+        {
+        }
+    }
+
+    if ( !pImpl->m_bVersionsAlreadyLoaded )
+        pImpl->m_bVersionsAlreadyLoaded = true;
+
+    return pImpl->aVersions;
+}
+
+uno::Sequence < util::RevisionTag > SfxMedium::GetVersionList( const uno::Reference < embed::XStorage >& xStorage )
+{
+    uno::Reference < document::XDocumentRevisionListPersistence > xReader =
+        document::DocumentRevisionListPersistence::create( comphelper::getProcessComponentContext() );
+    try
+    {
+        return xReader->load( xStorage );
+    }
+    catch ( const uno::Exception& )
+    {
+    }
+
+    return uno::Sequence < util::RevisionTag >();
+}
+
+void SfxMedium::AddVersion_Impl( util::RevisionTag& rRevision )
+{
+    if ( !GetStorage().is() )
+        return;
+
+    // To determine a unique name for the stream
+    std::vector<sal_uInt32> aLongs;
+    sal_Int32 nLength = pImpl->aVersions.getLength();
+    for ( const auto& rVersion : std::as_const(pImpl->aVersions) )
+    {
+        sal_uInt32 nVer = static_cast<sal_uInt32>( o3tl::toInt32(rVersion.Identifier.subView(7)));
+        size_t n;
+        for ( n=0; n<aLongs.size(); ++n )
+            if ( nVer<aLongs[n] )
+                break;
+
+        aLongs.insert( aLongs.begin()+n, nVer );
+    }
+
+    std::vector<sal_uInt32>::size_type nKey;
+    for ( nKey=0; nKey<aLongs.size(); ++nKey )
+        if ( aLongs[nKey] > nKey+1 )
+            break;
+
+    OUString aRevName = "Version" + OUString::number( nKey + 1 );
+    pImpl->aVersions.realloc( nLength+1 );
+    rRevision.Identifier = aRevName;
+    pImpl->aVersions.getArray()[nLength] = rRevision;
+}
+
+void SfxMedium::RemoveVersion_Impl( const OUString& rName )
+{
+    if ( !pImpl->aVersions.hasElements() )
+        return;
+
+    auto pVersion = std::find_if(std::cbegin(pImpl->aVersions), std::cend(pImpl->aVersions),
+        [&rName](const auto& rVersion) { return rVersion.Identifier == rName; });
+    if (pVersion != std::cend(pImpl->aVersions))
+    {
+        auto nIndex = static_cast<sal_Int32>(std::distance(std::cbegin(pImpl->aVersions), pVersion));
+        comphelper::removeElementAt(pImpl->aVersions, nIndex);
+    }
+}
+
+bool SfxMedium::TransferVersionList_Impl( SfxMedium const & rMedium )
+{
+    if ( rMedium.pImpl->aVersions.hasElements() )
+    {
+        pImpl->aVersions = rMedium.pImpl->aVersions;
+        return true;
+    }
+
+    return false;
+}
+
+void SfxMedium::SaveVersionList_Impl()
+{
+    if ( !GetStorage().is() )
+        return;
+
+    if ( !pImpl->aVersions.hasElements() )
+        return;
+
+    uno::Reference < document::XDocumentRevisionListPersistence > xWriter =
+             document::DocumentRevisionListPersistence::create( comphelper::getProcessComponentContext() );
+    try
+    {
+        xWriter->store( GetStorage(), pImpl->aVersions );
+    }
+    catch ( const uno::Exception& )
+    {
+    }
+}
+
+bool SfxMedium::IsReadOnly() const
+{
+    // a) ReadOnly filter can't produce read/write contents!
+    bool bReadOnly = pImpl->m_pFilter && (pImpl->m_pFilter->GetFilterFlags() & SfxFilterFlags::OPENREADONLY);
+
+    // b) if filter allow read/write contents .. check open mode of the storage
+    if (!bReadOnly)
+        bReadOnly = !( GetOpenMode() & StreamMode::WRITE );
+
+    // c) the API can force the readonly state!
+    if (!bReadOnly)
+    {
+        const SfxBoolItem* pItem = SfxItemSet::GetItem<SfxBoolItem>(GetItemSet(), SID_DOC_READONLY, false);
+        if (pItem)
+            bReadOnly = pItem->GetValue();
+    }
+
+    return bReadOnly;
+}
+
+bool SfxMedium::IsOriginallyReadOnly() const
+{
+    return pImpl->m_bOriginallyReadOnly;
+}
+
+void SfxMedium::SetOriginallyReadOnly(bool val)
+{
+    pImpl->m_bOriginallyReadOnly = val;
+}
+
+bool SfxMedium::IsOriginallyLoadedReadOnly() const
+{
+    return pImpl->m_bOriginallyLoadedReadOnly;
+}
+
+bool SfxMedium::SetWritableForUserOnly( const OUString& aURL )
+{
+    // UCB does not allow to allow write access only for the user,
+    // use osl API
+    bool bResult = false;
+
+    ::osl::DirectoryItem aDirItem;
+    if ( ::osl::DirectoryItem::get( aURL, aDirItem ) == ::osl::FileBase::E_None )
+    {
+        ::osl::FileStatus aFileStatus( osl_FileStatus_Mask_Attributes );
+        if ( aDirItem.getFileStatus( aFileStatus ) == osl::FileBase::E_None
+          && aFileStatus.isValid( osl_FileStatus_Mask_Attributes ) )
+        {
+            sal_uInt64 nAttributes = aFileStatus.getAttributes();
+
+            nAttributes &= ~(osl_File_Attribute_OwnWrite |
+                             osl_File_Attribute_GrpWrite |
+                             osl_File_Attribute_OthWrite |
+                             osl_File_Attribute_ReadOnly);
+            nAttributes |=  (osl_File_Attribute_OwnWrite |
+                             osl_File_Attribute_OwnRead);
+
+            bResult = ( osl::File::setAttributes( aURL, nAttributes ) == ::osl::FileBase::E_None );
+        }
+    }
+
+    return bResult;
+}
+
+namespace
+{
+/// Get the parent directory of a temporary file for output purposes.
+OUString GetLogicBase(const INetURLObject& rURL, std::unique_ptr<SfxMedium_Impl> const & pImpl)
+{
+    OUString aLogicBase;
+
+#if HAVE_FEATURE_MACOSX_SANDBOX
+    // In a sandboxed environment we don't want to attempt to create temporary files in the same
+    // directory where the user has selected an output file to be stored. The sandboxed process has
+    // permission only to create the specifically named output file in that directory.
+    (void) rURL;
+    (void) pImpl;
+#else
+
+    if (!pImpl->m_bHasEmbeddedObjects // Embedded objects would mean a special base, ignore that.
+        && rURL.GetProtocol() == INetProtocol::File && !pImpl->m_pInStream)
+    {
+        // Try to create the temp file in the same directory when storing.
+        INetURLObject aURL(rURL);
+        aURL.removeSegment();
+        aLogicBase = aURL.GetMainURL(INetURLObject::DecodeMechanism::WithCharset);
+    }
+
+#endif // !HAVE_FEATURE_MACOSX_SANDBOX
+
+    return aLogicBase;
+}
+}
+
+void SfxMedium::CreateTempFile( bool bReplace )
+{
+    if ( pImpl->pTempFile )
+    {
+        if ( !bReplace )
+            return;
+
+        pImpl->pTempFile.reset();
+        pImpl->m_aName.clear();
+    }
+
+    OUString aLogicBase = GetLogicBase(GetURLObject(), pImpl);
+    pImpl->pTempFile.reset(new ::utl::TempFile(&aLogicBase));
+    pImpl->pTempFile->EnableKillingFile();
+    pImpl->m_aName = pImpl->pTempFile->GetFileName();
+    OUString aTmpURL = pImpl->pTempFile->GetURL();
+    if ( pImpl->m_aName.isEmpty() || aTmpURL.isEmpty() )
+    {
+        SetError(ERRCODE_IO_CANTWRITE);
+        return;
+    }
+
+    if ( !(pImpl->m_nStorOpenMode & StreamMode::TRUNC) )
+    {
+        bool bTransferSuccess = false;
+
+        if ( GetContent().is()
+          && GetURLObject().GetProtocol() == INetProtocol::File
+          && ::utl::UCBContentHelper::IsDocument( GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ) ) )
+        {
+            // if there is already such a document, we should copy it
+            // if it is a file system use OS copy process
+            try
+            {
+                uno::Reference< css::ucb::XCommandEnvironment > xComEnv;
+                INetURLObject aTmpURLObj( aTmpURL );
+                OUString aFileName = aTmpURLObj.getName( INetURLObject::LAST_SEGMENT,
+                                                                true,
+                                                                INetURLObject::DecodeMechanism::WithCharset );
+                if ( !aFileName.isEmpty() && aTmpURLObj.removeSegment() )
+                {
+                    ::ucbhelper::Content aTargetContent( aTmpURLObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ), xComEnv, comphelper::getProcessComponentContext() );
+                    OUString sMimeType = pImpl->getFilterMimeType();
+                    aTargetContent.transferContent( pImpl->aContent, ::ucbhelper::InsertOperation::Copy, aFileName, NameClash::OVERWRITE, sMimeType );
+                    SetWritableForUserOnly( aTmpURL );
+                    bTransferSuccess = true;
+                }
+            }
+            catch( const uno::Exception& )
+            {}
+
+            if ( bTransferSuccess )
+            {
+                CloseOutStream();
+                CloseInStream();
+            }
+        }
+
+        if ( !bTransferSuccess && pImpl->m_pInStream )
+        {
+            // the case when there is no URL-access available or this is a remote protocol
+            // but there is an input stream
+            GetOutStream();
+            if ( pImpl->m_pOutStream )
+            {
+                std::unique_ptr<char[]> pBuf(new char [8192]);
+                ErrCode      nErr = ERRCODE_NONE;
+
+                pImpl->m_pInStream->Seek(0);
+                pImpl->m_pOutStream->Seek(0);
+
+                while( !pImpl->m_pInStream->eof() && nErr == ERRCODE_NONE )
+                {
+                    sal_uInt32 nRead = pImpl->m_pInStream->ReadBytes(pBuf.get(), 8192);
+                    nErr = pImpl->m_pInStream->GetError();
+                    pImpl->m_pOutStream->WriteBytes( pBuf.get(), nRead );
+                }
+
+                bTransferSuccess = true;
+                CloseInStream();
+            }
+            CloseOutStream_Impl();
+        }
+        else
+        {
+            // Quite strange design, but currently it is expected that in this case no transfer happens
+            // TODO/LATER: get rid of this inconsistent part of the call design
+            bTransferSuccess = true;
+            CloseInStream();
+        }
+
+        if ( !bTransferSuccess )
+        {
+            SetError(ERRCODE_IO_CANTWRITE);
+            return;
+        }
+    }
+
+    CloseStorage();
+}
+
+
+void SfxMedium::CreateTempFileNoCopy()
+{
+    // this call always replaces the existing temporary file
+    pImpl->pTempFile.reset();
+
+    OUString aLogicBase = GetLogicBase(GetURLObject(), pImpl);
+    pImpl->pTempFile.reset(new ::utl::TempFile(&aLogicBase));
+    pImpl->pTempFile->EnableKillingFile();
+    pImpl->m_aName = pImpl->pTempFile->GetFileName();
+    if ( pImpl->m_aName.isEmpty() )
+    {
+        SetError(ERRCODE_IO_CANTWRITE);
+        return;
+    }
+
+    CloseOutStream_Impl();
+    CloseStorage();
+}
+
+bool SfxMedium::SignDocumentContentUsingCertificate(
+    const css::uno::Reference<css::frame::XModel>& xModel, bool bHasValidDocumentSignature,
+    const Reference<XCertificate>& xCertificate)
+{
+    bool bChanges = false;
+
+    if (IsOpen() || GetError())
+    {
+        SAL_WARN("sfx.doc", "The medium must be closed by the signer!");
+        return bChanges;
+    }
+
+    // The component should know if there was a valid document signature, since
+    // it should show a warning in this case
+    OUString aODFVersion(comphelper::OStorageHelper::GetODFVersionFromStorage(GetStorage()));
+    uno::Reference< security::XDocumentDigitalSignatures > xSigner(
+        security::DocumentDigitalSignatures::createWithVersionAndValidSignature(
+            comphelper::getProcessComponentContext(), aODFVersion, bHasValidDocumentSignature ) );
+    auto xModelSigner = dynamic_cast<sfx2::DigitalSignatures*>(xSigner.get());
+    if (!xModelSigner)
+    {
+        return bChanges;
+    }
+
+    uno::Reference< embed::XStorage > xWriteableZipStor;
+
+    // we can reuse the temporary file if there is one already
+    CreateTempFile( false );
+    GetMedium_Impl();
+
+    try
+    {
+        if ( !pImpl->xStream.is() )
+            throw uno::RuntimeException();
+
+        bool bODF = GetFilter()->IsOwnFormat();
+        try
+        {
+            xWriteableZipStor = ::comphelper::OStorageHelper::GetStorageOfFormatFromStream( ZIP_STORAGE_FORMAT_STRING, pImpl->xStream );
+        }
+        catch (const io::IOException&)
+        {
+            if (bODF)
+            {
+                TOOLS_WARN_EXCEPTION("sfx.doc", "ODF stream is not a zip storage");
+            }
+        }
+
+        if ( !xWriteableZipStor.is() && bODF )
+            throw uno::RuntimeException();
+
+        uno::Reference< embed::XStorage > xMetaInf;
+        if (xWriteableZipStor.is() && xWriteableZipStor->hasByName("META-INF"))
+        {
+            xMetaInf = xWriteableZipStor->openStorageElement(
+                                            "META-INF",
+                                            embed::ElementModes::READWRITE );
+            if ( !xMetaInf.is() )
+                throw uno::RuntimeException();
+        }
+
+        {
+            if (xMetaInf.is())
+            {
+                // ODF.
+                uno::Reference< io::XStream > xStream;
+                if (GetFilter() && GetFilter()->IsOwnFormat())
+                    xStream.set(xMetaInf->openStreamElement(xSigner->getDocumentContentSignatureDefaultStreamName(), embed::ElementModes::READWRITE), uno::UNO_SET_THROW);
+
+                bool bSuccess = xModelSigner->SignModelWithCertificate(
+                    xModel, xCertificate, GetZipStorageToSign_Impl(), xStream);
+
+                if (bSuccess)
+                {
+                    uno::Reference< embed::XTransactedObject > xTransact( xMetaInf, uno::UNO_QUERY_THROW );
+                    xTransact->commit();
+                    xTransact.set( xWriteableZipStor, uno::UNO_QUERY_THROW );
+                    xTransact->commit();
+
+                    // the temporary file has been written, commit it to the original file
+                    Commit();
+                    bChanges = true;
+                }
+            }
+            else if (xWriteableZipStor.is())
+            {
+                // OOXML.
+                uno::Reference<io::XStream> xStream;
+
+                    // We need read-write to be able to add the signature relation.
+                bool bSuccess = xModelSigner->SignModelWithCertificate(
+                    xModel, xCertificate, GetZipStorageToSign_Impl(/*bReadOnly=*/false), xStream);
+
+                if (bSuccess)
+                {
+                    uno::Reference<embed::XTransactedObject> xTransact(xWriteableZipStor, uno::UNO_QUERY_THROW);
+                    xTransact->commit();
+
+                    // the temporary file has been written, commit it to the original file
+                    Commit();
+                    bChanges = true;
+                }
+            }
+            else
+            {
+                // Something not ZIP based: e.g. PDF.
+                std::unique_ptr<SvStream> pStream(utl::UcbStreamHelper::CreateStream(GetName(), StreamMode::READ | StreamMode::WRITE));
+                uno::Reference<io::XStream> xStream(new utl::OStreamWrapper(*pStream));
+                if (xModelSigner->SignModelWithCertificate(
+                        xModel, xCertificate, uno::Reference<embed::XStorage>(), xStream))
+                    bChanges = true;
+            }
+        }
+    }
+    catch ( const uno::Exception& )
+    {
+        SAL_WARN( "sfx.doc", "Couldn't use signing functionality!" );
+    }
+
+    CloseAndRelease();
+
+    ResetError();
+
+    return bChanges;
+}
+
+bool SfxMedium::SignContents_Impl(weld::Window* pDialogParent,
+                                  bool bSignScriptingContent,
+                                  bool bHasValidDocumentSignature,
+                                  const OUString& aSignatureLineId,
+                                  const Reference<XCertificate>& xCert,
+                                  const Reference<XGraphic>& xValidGraphic,
+                                  const Reference<XGraphic>& xInvalidGraphic,
+                                  const OUString& aComment)
+{
+    bool bChanges = false;
+
+    if (IsOpen() || GetError())
+    {
+        SAL_WARN("sfx.doc", "The medium must be closed by the signer!");
+        return bChanges;
+    }
+
+    // The component should know if there was a valid document signature, since
+    // it should show a warning in this case
+    OUString aODFVersion(comphelper::OStorageHelper::GetODFVersionFromStorage(GetStorage()));
+    uno::Reference< security::XDocumentDigitalSignatures > xSigner(
+        security::DocumentDigitalSignatures::createWithVersionAndValidSignature(
+            comphelper::getProcessComponentContext(), aODFVersion, bHasValidDocumentSignature ) );
+    if (pDialogParent)
+        xSigner->setParentWindow(pDialogParent->GetXWindow());
+
+    uno::Reference< embed::XStorage > xWriteableZipStor;
+
+    // we can reuse the temporary file if there is one already
+    CreateTempFile( false );
+    GetMedium_Impl();
+
+    try
+    {
+        if ( !pImpl->xStream.is() )
+            throw uno::RuntimeException();
+
+        bool bODF = GetFilter()->IsOwnFormat();
+        try
+        {
+            xWriteableZipStor = ::comphelper::OStorageHelper::GetStorageOfFormatFromStream( ZIP_STORAGE_FORMAT_STRING, pImpl->xStream );
+        }
+        catch (const io::IOException&)
+        {
+            if (bODF)
+            {
+                TOOLS_WARN_EXCEPTION("sfx.doc", "ODF stream is not a zip storage");
+            }
+        }
+
+        if ( !xWriteableZipStor.is() && bODF )
+            throw uno::RuntimeException();
+
+        uno::Reference< embed::XStorage > xMetaInf;
+        if (xWriteableZipStor.is() && xWriteableZipStor->hasByName("META-INF"))
+        {
+            xMetaInf = xWriteableZipStor->openStorageElement(
+                                            "META-INF",
+                                            embed::ElementModes::READWRITE );
+            if ( !xMetaInf.is() )
+                throw uno::RuntimeException();
+        }
+
+        if ( bSignScriptingContent )
+        {
+            // If the signature has already the document signature it will be removed
+            // after the scripting signature is inserted.
+            uno::Reference< io::XStream > xStream(
+                xMetaInf->openStreamElement( xSigner->getScriptingContentSignatureDefaultStreamName(),
+                                                embed::ElementModes::READWRITE ),
+                uno::UNO_SET_THROW );
+
+            if ( xSigner->signScriptingContent( GetZipStorageToSign_Impl(), xStream ) )
+            {
+                // remove the document signature if any
+                OUString aDocSigName = xSigner->getDocumentContentSignatureDefaultStreamName();
+                if ( !aDocSigName.isEmpty() && xMetaInf->hasByName( aDocSigName ) )
+                    xMetaInf->removeElement( aDocSigName );
+
+                uno::Reference< embed::XTransactedObject > xTransact( xMetaInf, uno::UNO_QUERY_THROW );
+                xTransact->commit();
+                xTransact.set( xWriteableZipStor, uno::UNO_QUERY_THROW );
+                xTransact->commit();
+
+                // the temporary file has been written, commit it to the original file
+                Commit();
+                bChanges = true;
+            }
+        }
+        else
+        {
+            if (xMetaInf.is())
+            {
+                // ODF.
+                uno::Reference< io::XStream > xStream;
+                if (GetFilter() && GetFilter()->IsOwnFormat())
+                    xStream.set(xMetaInf->openStreamElement(xSigner->getDocumentContentSignatureDefaultStreamName(), embed::ElementModes::READWRITE), uno::UNO_SET_THROW);
+
+                bool bSuccess = false;
+                if (xCert.is())
+                    bSuccess = xSigner->signSignatureLine(
+                        GetZipStorageToSign_Impl(), xStream, aSignatureLineId, xCert,
+                        xValidGraphic, xInvalidGraphic, aComment);
+                else
+                    bSuccess = xSigner->signDocumentContent(GetZipStorageToSign_Impl(),
+                                                            xStream);
+
+                if (bSuccess)
+                {
+                    uno::Reference< embed::XTransactedObject > xTransact( xMetaInf, uno::UNO_QUERY_THROW );
+                    xTransact->commit();
+                    xTransact.set( xWriteableZipStor, uno::UNO_QUERY_THROW );
+                    xTransact->commit();
+
+                    // the temporary file has been written, commit it to the original file
+                    Commit();
+                    bChanges = true;
+                }
+            }
+            else if (xWriteableZipStor.is())
+            {
+                // OOXML.
+                uno::Reference<io::XStream> xStream;
+
+                bool bSuccess = false;
+                if (xCert.is())
+                {
+                    bSuccess = xSigner->signSignatureLine(
+                        GetZipStorageToSign_Impl(/*bReadOnly=*/false), xStream, aSignatureLineId,
+                        xCert, xValidGraphic, xInvalidGraphic, aComment);
+                }
+                else
+                {
+                    // We need read-write to be able to add the signature relation.
+                    bSuccess =xSigner->signDocumentContent(
+                        GetZipStorageToSign_Impl(/*bReadOnly=*/false), xStream);
+                }
+
+                if (bSuccess)
+                {
+                    uno::Reference<embed::XTransactedObject> xTransact(xWriteableZipStor, uno::UNO_QUERY_THROW);
+                    xTransact->commit();
+
+                    // the temporary file has been written, commit it to the original file
+                    Commit();
+                    bChanges = true;
+                }
+            }
+            else
+            {
+                // Something not ZIP based: e.g. PDF.
+                std::unique_ptr<SvStream> pStream(utl::UcbStreamHelper::CreateStream(GetName(), StreamMode::READ | StreamMode::WRITE));
+                uno::Reference<io::XStream> xStream(new utl::OStreamWrapper(*pStream));
+                if (xSigner->signDocumentContent(uno::Reference<embed::XStorage>(), xStream))
+                    bChanges = true;
+            }
+        }
+    }
+    catch ( const uno::Exception& )
+    {
+        SAL_WARN( "sfx.doc", "Couldn't use signing functionality!" );
+    }
+
+    CloseAndRelease();
+
+    ResetError();
+
+    return bChanges;
+}
+
+
+SignatureState SfxMedium::GetCachedSignatureState_Impl() const
+{
+    return pImpl->m_nSignatureState;
+}
+
+
+void SfxMedium::SetCachedSignatureState_Impl( SignatureState nState )
+{
+    pImpl->m_nSignatureState = nState;
+}
+
+void SfxMedium::SetHasEmbeddedObjects(bool bHasEmbeddedObjects)
+{
+    pImpl->m_bHasEmbeddedObjects = bHasEmbeddedObjects;
+}
+
+bool SfxMedium::HasStorage_Impl() const
+{
+    return pImpl->xStorage.is();
+}
+
+bool SfxMedium::IsOpen() const
+{
+    return pImpl->m_pInStream || pImpl->m_pOutStream || pImpl->xStorage.is();
+}
+
+OUString SfxMedium::CreateTempCopyWithExt( std::u16string_view aURL )
+{
+    OUString aResult;
+
+    if ( !aURL.empty() )
+    {
+        size_t nPrefixLen = aURL.rfind( '.' );
+        OUString aExt = ( nPrefixLen == std::u16string_view::npos ) ? OUString() : OUString(aURL.substr( nPrefixLen ));
+
+        OUString aNewTempFileURL = ::utl::TempFile( u"", true, &aExt ).GetURL();
+        if ( !aNewTempFileURL.isEmpty() )
+        {
+            INetURLObject aSource( aURL );
+            INetURLObject aDest( aNewTempFileURL );
+            OUString aFileName = aDest.getName( INetURLObject::LAST_SEGMENT,
+                                                        true,
+                                                        INetURLObject::DecodeMechanism::WithCharset );
+            if ( !aFileName.isEmpty() && aDest.removeSegment() )
+            {
+                try
+                {
+                    uno::Reference< css::ucb::XCommandEnvironment > xComEnv;
+                    ::ucbhelper::Content aTargetContent( aDest.GetMainURL( INetURLObject::DecodeMechanism::NONE ), xComEnv, comphelper::getProcessComponentContext() );
+                    ::ucbhelper::Content aSourceContent( aSource.GetMainURL( INetURLObject::DecodeMechanism::NONE ), xComEnv, comphelper::getProcessComponentContext() );
+                    aTargetContent.transferContent( aSourceContent,
+                                                        ::ucbhelper::InsertOperation::Copy,
+                                                        aFileName,
+                                                        NameClash::OVERWRITE );
+                    aResult = aNewTempFileURL;
+                }
+                catch( const uno::Exception& )
+                {}
+            }
+        }
+    }
+
+    return aResult;
+}
+
+bool SfxMedium::CallApproveHandler(const uno::Reference< task::XInteractionHandler >& xHandler, const uno::Any& rRequest, bool bAllowAbort)
+{
+    bool bResult = false;
+
+    if ( xHandler.is() )
+    {
+        try
+        {
+            uno::Sequence< uno::Reference< task::XInteractionContinuation > > aContinuations( bAllowAbort ? 2 : 1 );
+            auto pContinuations = aContinuations.getArray();
+
+            ::rtl::Reference< ::comphelper::OInteractionApprove > pApprove( new ::comphelper::OInteractionApprove );
+            pContinuations[ 0 ] = pApprove.get();
+
+            if ( bAllowAbort )
+            {
+                ::rtl::Reference< ::comphelper::OInteractionAbort > pAbort( new ::comphelper::OInteractionAbort );
+                pContinuations[ 1 ] = pAbort.get();
+            }
+
+            xHandler->handle(::framework::InteractionRequest::CreateRequest(rRequest, aContinuations));
+            bResult = pApprove->wasSelected();
+        }
+        catch( const Exception& )
+        {
+        }
+    }
+
+    return bResult;
+}
+
+OUString SfxMedium::SwitchDocumentToTempFile()
+{
+    // the method returns empty string in case of failure
+    OUString aResult;
+    OUString aOrigURL = pImpl->m_aLogicName;
+
+    if ( !aOrigURL.isEmpty() )
+    {
+        sal_Int32 nPrefixLen = aOrigURL.lastIndexOf( '.' );
+        OUString const aExt = (nPrefixLen == -1)
+                                ? OUString()
+                                : aOrigURL.copy(nPrefixLen);
+        OUString aNewURL = ::utl::TempFile( u"", true, &aExt ).GetURL();
+
+        // TODO/LATER: In future the aLogicName should be set to shared folder URL
+        //             and a temporary file should be created. Transport_Impl should be impossible then.
+        if ( !aNewURL.isEmpty() )
+        {
+            uno::Reference< embed::XStorage > xStorage = GetStorage();
+            uno::Reference< embed::XOptimizedStorage > xOptStorage( xStorage, uno::UNO_QUERY );
+
+            if ( xOptStorage.is() )
+            {
+                // TODO/LATER: reuse the pImpl->pTempFile if it already exists
+                CanDisposeStorage_Impl( false );
+                Close();
+                SetPhysicalName_Impl( OUString() );
+                SetName( aNewURL );
+
+                // remove the readonly state
+                bool bWasReadonly = false;
+                pImpl->m_nStorOpenMode = SFX_STREAM_READWRITE;
+                const SfxBoolItem* pReadOnlyItem = SfxItemSet::GetItem<SfxBoolItem>(pImpl->m_pSet.get(), SID_DOC_READONLY, false);
+                if ( pReadOnlyItem && pReadOnlyItem->GetValue() )
+                    bWasReadonly = true;
+                GetItemSet()->ClearItem( SID_DOC_READONLY );
+
+                GetMedium_Impl();
+                LockOrigFileOnDemand( false, false );
+                CreateTempFile();
+                GetMedium_Impl();
+
+                if ( pImpl->xStream.is() )
+                {
+                    try
+                    {
+                        xOptStorage->writeAndAttachToStream( pImpl->xStream );
+                        pImpl->xStorage = xStorage;
+                        aResult = aNewURL;
+                    }
+                    catch( const uno::Exception& )
+                    {}
+                }
+
+                if (bWasReadonly)
+                {
+                    // set the readonly state back
+                    pImpl->m_nStorOpenMode = SFX_STREAM_READONLY;
+                    GetItemSet()->Put(SfxBoolItem(SID_DOC_READONLY, true));
+                }
+
+                if ( aResult.isEmpty() )
+                {
+                    Close();
+                    SetPhysicalName_Impl( OUString() );
+                    SetName( aOrigURL );
+                    GetMedium_Impl();
+                    pImpl->xStorage = xStorage;
+                }
+            }
+        }
+    }
+
+    return aResult;
+}
+
+bool SfxMedium::SwitchDocumentToFile( const OUString& aURL )
+{
+    // the method is only for storage based documents
+    bool bResult = false;
+    OUString aOrigURL = pImpl->m_aLogicName;
+
+    if ( !aURL.isEmpty() && !aOrigURL.isEmpty() )
+    {
+        uno::Reference< embed::XStorage > xStorage = GetStorage();
+        uno::Reference< embed::XOptimizedStorage > xOptStorage( xStorage, uno::UNO_QUERY );
+
+        // TODO/LATER: reuse the pImpl->pTempFile if it already exists
+        CanDisposeStorage_Impl( false );
+        Close();
+        SetPhysicalName_Impl( OUString() );
+        SetName( aURL );
+
+        // open the temporary file based document
+        GetMedium_Impl();
+        LockOrigFileOnDemand( false, false );
+        CreateTempFile();
+        GetMedium_Impl();
+
+        if ( pImpl->xStream.is() )
+        {
+            try
+            {
+                uno::Reference< io::XTruncate > xTruncate( pImpl->xStream, uno::UNO_QUERY_THROW );
+                xTruncate->truncate();
+                if ( xOptStorage.is() )
+                    xOptStorage->writeAndAttachToStream( pImpl->xStream );
+                pImpl->xStorage = xStorage;
+                bResult = true;
+            }
+            catch( const uno::Exception& )
+            {}
+        }
+
+        if ( !bResult )
+        {
+            Close();
+            SetPhysicalName_Impl( OUString() );
+            SetName( aOrigURL );
+            GetMedium_Impl();
+            pImpl->xStorage = xStorage;
+        }
+    }
+
+    return bResult;
+}
+
+void SfxMedium::SetInCheckIn( bool bInCheckIn )
+{
+    pImpl->m_bInCheckIn = bInCheckIn;
+}
+
+bool SfxMedium::IsInCheckIn( ) const
+{
+    return pImpl->m_bInCheckIn;
+}
+
+// should only be called on main thread
+const std::shared_ptr<std::recursive_mutex>& SfxMedium::GetCheckEditableMutex() const
+{
+    return pImpl->m_pCheckEditableWorkerMutex;
+}
+
+// should only be called while holding pImpl->m_pCheckEditableWorkerMutex
+void SfxMedium::SetWorkerReloadEvent(ImplSVEvent* pEvent)
+{
+    pImpl->m_pReloadEvent = pEvent;
+}
+
+// should only be called while holding pImpl->m_pCheckEditableWorkerMutex
+ImplSVEvent* SfxMedium::GetWorkerReloadEvent() const
+{
+    return pImpl->m_pReloadEvent;
+}
+
+// should only be called on main thread
+void SfxMedium::AddToCheckEditableWorkerList()
+{
+    if (!pImpl->m_bNotifyWhenEditable)
+        return;
+
+    CancelCheckEditableEntry();
+
+    if (pImpl->m_pCheckEditableWorkerMutex == nullptr)
+    {
+        pImpl->m_pCheckEditableWorkerMutex = std::make_shared<std::recursive_mutex>();
+        if (pImpl->m_pCheckEditableWorkerMutex == nullptr)
+            return;
+    }
+
+    pImpl->m_pIsDestructed = std::make_shared<bool>(false);
+    if (pImpl->m_pIsDestructed == nullptr)
+        return;
+
+    std::unique_lock<std::mutex> globalLock(g_chkReadOnlyGlobalMutex);
+    if (g_newReadOnlyDocs.find(this) == g_newReadOnlyDocs.end())
+    {
+        bool bAddNewEntry = false;
+        if (!g_bChkReadOnlyTaskRunning)
+        {
+            std::shared_ptr<comphelper::ThreadTaskTag> pTag
+                = comphelper::ThreadPool::createThreadTaskTag();
+            if (pTag != nullptr)
+            {
+                g_bChkReadOnlyTaskRunning = true;
+                bAddNewEntry = true;
+                comphelper::ThreadPool::getSharedOptimalPool().pushTask(
+                    std::make_unique<CheckReadOnlyTask>(pTag));
+            }
+        }
+        else
+            bAddNewEntry = true;
+
+        if (bAddNewEntry)
+        {
+            std::shared_ptr<ReadOnlyMediumEntry> newEntry = std::make_shared<ReadOnlyMediumEntry>(
+                pImpl->m_pCheckEditableWorkerMutex, pImpl->m_pIsDestructed);
+
+            if (newEntry != nullptr)
+            {
+                g_newReadOnlyDocs[this] = newEntry;
+            }
+        }
+    }
+}
+
+// should only be called on main thread
+void SfxMedium::CancelCheckEditableEntry(bool bRemoveEvent)
+{
+    if (pImpl->m_pCheckEditableWorkerMutex != nullptr)
+    {
+        std::unique_lock<std::recursive_mutex> lock(*(pImpl->m_pCheckEditableWorkerMutex));
+
+        if (pImpl->m_pReloadEvent != nullptr)
+        {
+            if (bRemoveEvent)
+                Application::RemoveUserEvent(pImpl->m_pReloadEvent);
+            // make sure destructor doesn't use a freed reference
+            // and reset the event so we can check again
+            pImpl->m_pReloadEvent = nullptr;
+        }
+
+        if (pImpl->m_pIsDestructed != nullptr)
+        {
+            *(pImpl->m_pIsDestructed) = true;
+            pImpl->m_pIsDestructed = nullptr;
+        }
+    }
+}
+
+/** callback function, which is triggered by worker thread after successfully checking if the file
+     is editable. Sent from <Application::PostUserEvent(..)>
+     Note: This method has to be run in the main thread.
+*/
+IMPL_STATIC_LINK(SfxMedium, ShowReloadEditableDialog, void*, p, void)
+{
+    SfxMedium* pMed = static_cast<SfxMedium*>(p);
+    if (pMed == nullptr)
+        return;
+
+    pMed->CancelCheckEditableEntry(false);
+
+    uno::Reference<task::XInteractionHandler> xHandler = pMed->GetInteractionHandler();
+    if (xHandler.is())
+    {
+        OUString aDocumentURL
+            = pMed->GetURLObject().GetLastName(INetURLObject::DecodeMechanism::WithCharset);
+        ::rtl::Reference<::ucbhelper::InteractionRequest> xInteractionRequestImpl
+            = new ::ucbhelper::InteractionRequest(uno::Any(document::ReloadEditableRequest(
+                OUString(), uno::Reference<uno::XInterface>(), aDocumentURL)));
+        if (xInteractionRequestImpl != nullptr)
+        {
+            uno::Sequence<uno::Reference<task::XInteractionContinuation>> aContinuations{
+                new ::ucbhelper::InteractionAbort(xInteractionRequestImpl.get()),
+                new ::ucbhelper::InteractionApprove(xInteractionRequestImpl.get())
+            };
+            xInteractionRequestImpl->setContinuations(aContinuations);
+            xHandler->handle(xInteractionRequestImpl);
+            ::rtl::Reference<::ucbhelper::InteractionContinuation> xSelected
+                = xInteractionRequestImpl->getSelection();
+            if (uno::Reference<task::XInteractionApprove>(xSelected.get(), uno::UNO_QUERY).is())
+            {
+                for (SfxViewFrame* pFrame = SfxViewFrame::GetFirst(); pFrame;
+                     pFrame = SfxViewFrame::GetNext(*pFrame))
+                {
+                    if (pFrame->GetObjectShell()->GetMedium() == pMed)
+                    {
+                        // special case to ensure view isn't set to read-only in
+                        // SfxViewFrame::ExecReload_Impl after reloading
+                        pMed->SetOriginallyReadOnly(false);
+                        pFrame->GetDispatcher()->Execute(SID_RELOAD);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+}
+
+bool SfxMedium::CheckCanGetLockfile() const
+{
+#if !HAVE_FEATURE_MULTIUSER_ENVIRONMENT
+    bool bCanReload = true;
+#else
+    bool bCanReload = false;
+    ::svt::DocumentLockFile aLockFile(GetName());
+    LockFileEntry aData;
+    osl::DirectoryItem rItem;
+    auto nError1 = osl::DirectoryItem::get(aLockFile.GetURL(), rItem);
+    if (nError1 == osl::FileBase::E_None)
+    {
+        try
+        {
+            aData = aLockFile.GetLockData();
+        }
+        catch (const io::WrongFormatException&)
+        {
+            // we get empty or corrupt data
+            return false;
+        }
+        catch (const uno::Exception&)
+        {
+            // locked from other app
+            return false;
+        }
+        LockFileEntry aOwnData = svt::LockFileCommon::GenerateOwnEntry();
+        bool bOwnLock
+            = aOwnData[LockFileComponent::SYSUSERNAME] == aData[LockFileComponent::SYSUSERNAME];
+        if (bOwnLock
+            && aOwnData[LockFileComponent::LOCALHOST] == aData[LockFileComponent::LOCALHOST]
+            && aOwnData[LockFileComponent::USERURL] == aData[LockFileComponent::USERURL])
+        {
+            // this is own lock from the same installation, it could remain because of crash
+            bCanReload = true;
+        }
+    }
+    else if (nError1 == osl::FileBase::E_NOENT) // file doesn't exist
+    {
+        try
+        {
+            aLockFile.CreateOwnLockFile();
+            try
+            {
+                // TODO/LATER: A warning could be shown in case the file is not the own one
+                aLockFile.RemoveFile();
+            }
+            catch (const io::WrongFormatException&)
+            {
+                try
+                {
+                    // erase the empty or corrupt file
+                    aLockFile.RemoveFileDirectly();
+                }
+                catch (const uno::Exception&)
+                {
+                }
+            }
+            bCanReload = true;
+        }
+        catch (const uno::Exception&)
+        {
+        }
+    }
+#endif
+    return bCanReload;
+}
+
+// worker thread method, should only be one thread globally
+void CheckReadOnlyTask::doWork()
+{
+    if (m_xListener == nullptr)
+        return;
+
+    while (true)
+    {
+        std::unique_lock<std::mutex> termLock(m_xListener->mMutex);
+        if (m_xListener->mCond.wait_for(termLock, std::chrono::seconds(60),
+                                        [this] { return m_xListener->bIsTerminated; }))
+            // signalled, spurious wakeups should not be possible
+            return;
+
+        // must have timed-out
+        termLock.unlock();
+        std::unique_lock<std::mutex> globalLock(g_chkReadOnlyGlobalMutex);
+        for (auto it = g_newReadOnlyDocs.begin(); it != g_newReadOnlyDocs.end(); )
+        {
+            auto [pMed, roEntry] = *it;
+            g_existingReadOnlyDocs[pMed] = roEntry;
+            it = g_newReadOnlyDocs.erase(it);
+        }
+        if (g_existingReadOnlyDocs.size() == 0)
+        {
+            g_bChkReadOnlyTaskRunning = false;
+            return;
+        }
+        globalLock.unlock();
+
+        auto checkForErase = [](SfxMedium* pMed, const std::shared_ptr<ReadOnlyMediumEntry>& roEntry) -> bool
+        {
+            if (pMed == nullptr || roEntry == nullptr || roEntry->_pMutex == nullptr
+                || roEntry->_pIsDestructed == nullptr)
+                return true;
+
+            std::unique_lock<std::recursive_mutex> medLock(*(roEntry->_pMutex));
+            if (*(roEntry->_pIsDestructed) || pMed->GetWorkerReloadEvent() != nullptr)
+                return true;
+
+            osl::File aFile(
+                pMed->GetURLObject().GetMainURL(INetURLObject::DecodeMechanism::WithCharset));
+            if (aFile.open(osl_File_OpenFlag_Write) != osl::FileBase::E_None)
+                return false;
+
+            if (!pMed->CheckCanGetLockfile())
+                return false;
+
+            if (aFile.close() != osl::FileBase::E_None)
+                return true;
+
+            // we can load, ask user
+            ImplSVEvent* pEvent = Application::PostUserEvent(
+                LINK(nullptr, SfxMedium, ShowReloadEditableDialog), pMed);
+            pMed->SetWorkerReloadEvent(pEvent);
+            return true;
+        };
+
+        for (auto it = g_existingReadOnlyDocs.begin(); it != g_existingReadOnlyDocs.end(); )
+        {
+            if (checkForErase(it->first, it->second))
+                it = g_existingReadOnlyDocs.erase(it);
+            else
+                ++it;
+        }
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */