Quelle  oleembed.cxx   Sprache: C

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * 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 <sal/config.h>

#include <string_view>

#include <oleembobj.hxx>
#include <com/sun/star/embed/EmbedStates.hpp>
#include <com/sun/star/embed/EmbedVerbs.hpp>
#include <com/sun/star/embed/UnreachableStateException.hpp>
#include <com/sun/star/embed/XStorage.hpp>
#include <com/sun/star/embed/ElementModes.hpp>
#include <com/sun/star/embed/EmbedUpdateModes.hpp>
#include <com/sun/star/embed/NeedsRunningStateException.hpp>
#include <com/sun/star/embed/StateChangeInProgressException.hpp>
#include <com/sun/star/embed/EmbedMisc.hpp>
#include <com/sun/star/embed/XEmbedObjectCreator.hpp>
#include <com/sun/star/io/TempFile.hpp>
#include <com/sun/star/io/XSeekable.hpp>
#include <com/sun/star/lang/DisposedException.hpp>
#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
#include <com/sun/star/beans/NamedValue.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/frame/XLoadable.hpp>
#include <com/sun/star/document/XStorageBasedDocument.hpp>
#include <com/sun/star/ucb/SimpleFileAccess.hpp>
#include <com/sun/star/container/XNameAccess.hpp>
#include <com/sun/star/container/XNameContainer.hpp>
#include <com/sun/star/system/SystemShellExecute.hpp>
#include <com/sun/star/system/SystemShellExecuteFlags.hpp>

#include <cppuhelper/exc_hlp.hxx>
#include <comphelper/multicontainer2.hxx>
#include <comphelper/mimeconfighelper.hxx>
#include <comphelper/propertyvalue.hxx>
#include <sal/log.hxx>
#include <comphelper/diagnose_ex.hxx>
#include <officecfg/Office/Common.hxx>

#include <targetstatecontrol.hxx>

#include "ownview.hxx"

#if defined(_WIN32)
#include "olecomponent.hxx"
#endif

using namespace ::com::sun::star;

#ifdef _WIN32

void OleEmbeddedObject::SwitchComponentToRunningState_Impl(osl::ResettableMutexGuard& guard)
{
    if ( !m_pOleComponent )
    {
        throw embed::UnreachableStateException();
    }
    try
    {
        m_pOleComponent->RunObject();
    }
    catch( const embed::UnreachableStateException& )
    {
        GetRidOfComponent(&guard);
        throw;
    }
    catch( const embed::WrongStateException& )
    {
        GetRidOfComponent(&guard);
        throw;
    }
}


uno::Sequence< sal_Int32 > OleEmbeddedObject::GetReachableStatesList_Impl(
                                                        const uno::Sequence< embed::VerbDescriptor >& aVerbList )
{
    uno::Sequence< sal_Int32 > aStates { embed::EmbedStates::LOADED, embed::EmbedStates::RUNNING };
    for ( embed::VerbDescriptor const & vd : aVerbList )
        if ( vd.VerbID == embed::EmbedVerbs::MS_OLEVERB_OPEN )
        {
            aStates.realloc(3);
            aStates.getArray()[2] = embed::EmbedStates::ACTIVE;
            break;
        }

    return aStates;
}


uno::Sequence< sal_Int32 > OleEmbeddedObject::GetIntermediateVerbsSequence_Impl( sal_Int32 nNewState )
{
    SAL_WARN_IF( m_nObjectState == embed::EmbedStates::LOADED, "embeddedobj.ole", "Loaded object is switched to running state without verbs using!" );

    // actually there will be only one verb
    if ( m_nObjectState == embed::EmbedStates::RUNNING && nNewState == embed::EmbedStates::ACTIVE )
    {
        return { embed::EmbedVerbs::MS_OLEVERB_OPEN };
    }

    return uno::Sequence< sal_Int32 >();
}
#endif

void OleEmbeddedObject::MoveListeners()
{
    if ( !m_pInterfaceContainer )
        return;

    // move state change listeners
    {
        comphelper::OInterfaceContainerHelper2* pStateChangeContainer =
            m_pInterfaceContainer->getContainer( cppu::UnoType<embed::XStateChangeListener>::get());
        if ( pStateChangeContainer != nullptr )
        {
            if ( m_xWrappedObject.is() )
            {
                comphelper::OInterfaceIteratorHelper2 pIterator( *pStateChangeContainer );
                while ( pIterator.hasMoreElements() )
                {
                    try
                    {
                        m_xWrappedObject->addStateChangeListener( static_cast<embed::XStateChangeListener*>(pIterator.next()) );
                    }
                    catch( const uno::RuntimeException& )
                    {
                        pIterator.remove();
                    }
                }
            }
        }
    }

    // move event listeners
    {
        comphelper::OInterfaceContainerHelper2* pEventContainer =
            m_pInterfaceContainer->getContainer( cppu::UnoType<document::XEventListener>::get());
        if ( pEventContainer != nullptr )
        {
            if ( m_xWrappedObject.is() )
            {
                comphelper::OInterfaceIteratorHelper2 pIterator( *pEventContainer );
                while ( pIterator.hasMoreElements() )
                {
                    try
                    {
                        m_xWrappedObject->addEventListener( static_cast<document::XEventListener*>(pIterator.next()) );
                    }
                    catch( const uno::RuntimeException& )
                    {
                        pIterator.remove();
                    }
                }
            }
        }
    }

    // move close listeners
    {
        comphelper::OInterfaceContainerHelper2* pCloseContainer =
            m_pInterfaceContainer->getContainer( cppu::UnoType<util::XCloseListener>::get());
        if ( pCloseContainer != nullptr )
        {
            if ( m_xWrappedObject.is() )
            {
                comphelper::OInterfaceIteratorHelper2 pIterator( *pCloseContainer );
                while ( pIterator.hasMoreElements() )
                {
                    try
                    {
                        m_xWrappedObject->addCloseListener( static_cast<util::XCloseListener*>(pIterator.next()) );
                    }
                    catch( const uno::RuntimeException& )
                    {
                        pIterator.remove();
                    }
                }
            }
        }
    }

    m_pInterfaceContainer.reset();
}


uno::Reference< embed::XStorage > OleEmbeddedObject::CreateTemporarySubstorage( OUString& o_aStorageName )
{
    uno::Reference< embed::XStorage > xResult;

    for ( sal_Int32 nInd = 0; nInd < 32000 && !xResult.is(); nInd++ )
    {
        OUString aName = OUString::number( nInd ) + "TMPSTOR" + m_aEntryName;
        if ( !m_xParentStorage->hasByName( aName ) )
        {
            xResult = m_xParentStorage->openStorageElement( aName, embed::ElementModes::READWRITE );
            o_aStorageName = aName;
        }
    }

    if ( !xResult.is() )
    {
        o_aStorageName.clear();
        throw uno::RuntimeException(u"Failed to create temporary storage for OLE embed object"_ustr);
    }

    return xResult;
}


OUString OleEmbeddedObject::MoveToTemporarySubstream()
{
    OUString aResult;
    for ( sal_Int32 nInd = 0; nInd < 32000 && aResult.isEmpty(); nInd++ )
    {
        OUString aName = OUString::number( nInd ) + "TMPSTREAM" + m_aEntryName;
        if ( !m_xParentStorage->hasByName( aName ) )
        {
            m_xParentStorage->renameElement( m_aEntryName, aName );
            aResult = aName;
        }
    }

    if ( aResult.isEmpty() )
        throw uno::RuntimeException(u"Failed to rename temporary storage for OLE embed object"_ustr);

    return aResult;
}


bool OleEmbeddedObject::TryToConvertToOOo( const uno::Reference< io::XStream >& xStream )
{
    bool bResult = false;

    OUString aStorageName;
    OUString aTmpStreamName;
    sal_Int32 nStep = 0;

    if ( m_pOleComponent || m_bReadOnly )
        return false;

    try
    {
        changeState( embed::EmbedStates::LOADED );

        // the stream must be seekable
        uno::Reference< io::XSeekable > xSeekable( xStream, uno::UNO_QUERY_THROW );
        xSeekable->seek( 0 );
        m_aFilterName = OwnView_Impl::GetFilterNameFromExtentionAndInStream( m_xContext, std::u16string_view(), xStream->getInputStream() );

        if ( !m_aFilterName.isEmpty()
          && ( m_aFilterName == "Calc MS Excel 2007 XML" || m_aFilterName == "Impress MS PowerPoint 2007 XML" || m_aFilterName == "MS Word 2007 XML"
              || m_aFilterName == "MS Excel 97 Vorlage/Template" || m_aFilterName == "MS Word 97 Vorlage" ) )
        {
            uno::Reference< container::XNameAccess > xFilterFactory(
                m_xContext->getServiceManager()->createInstanceWithContext(u"com.sun.star.document.FilterFactory"_ustr, m_xContext),
                uno::UNO_QUERY_THROW );

            OUString aDocServiceName;
            uno::Any aFilterAnyData = xFilterFactory->getByName( m_aFilterName );
            uno::Sequence< beans::PropertyValue > aFilterData;
            if ( aFilterAnyData >>= aFilterData )
            {
                for (beans::PropertyValue const& prop : aFilterData)
                    if ( prop.Name == "DocumentService" )
                        prop.Value >>= aDocServiceName;
            }

            if ( !aDocServiceName.isEmpty() )
            {
                // create the model
                uno::Sequence< uno::Any > aArguments{ uno::Any(
                    beans::NamedValue( u"EmbeddedObject"_ustr, uno::Any( true ))) };

                uno::Reference< util::XCloseable > xDocument( m_xContext->getServiceManager()->createInstanceWithArgumentsAndContext( aDocServiceName, aArguments, m_xContext ), uno::UNO_QUERY_THROW );
                uno::Reference< frame::XLoadable > xLoadable( xDocument, uno::UNO_QUERY_THROW );
                uno::Reference< document::XStorageBasedDocument > xStorDoc( xDocument, uno::UNO_QUERY_THROW );

                // let the model behave as embedded one
                uno::Reference< frame::XModel > xModel( xDocument, uno::UNO_QUERY_THROW );
                uno::Sequence< beans::PropertyValue > aSeq{ comphelper::makePropertyValue(
                    u"SetEmbedded"_ustr, true) };
                xModel->attachResource( OUString(), aSeq );

                // load the model from the stream
                uno::Sequence< beans::PropertyValue > aArgs{
                    comphelper::makePropertyValue(u"HierarchicalDocumentName"_ustr, m_aEntryName),
                    comphelper::makePropertyValue(u"ReadOnly"_ustr, true),
                    comphelper::makePropertyValue(u"FilterName"_ustr, m_aFilterName),
                    comphelper::makePropertyValue(u"URL"_ustr, u"private:stream"_ustr),
                    comphelper::makePropertyValue(u"InputStream"_ustr, xStream->getInputStream())
                };

                xSeekable->seek( 0 );
                xLoadable->load( aArgs );

                // the model is successfully loaded, create a new storage and store the model to the storage
                uno::Reference< embed::XStorage > xTmpStorage = CreateTemporarySubstorage( aStorageName );
                xStorDoc->storeToStorage( xTmpStorage, uno::Sequence< beans::PropertyValue >() );
                xDocument->close( true );
                uno::Reference< beans::XPropertySet > xStorProps( xTmpStorage, uno::UNO_QUERY_THROW );
                OUString aMediaType;
                xStorProps->getPropertyValue(u"MediaType"_ustr) >>= aMediaType;
                xTmpStorage->dispose();

                // look for the related embedded object factory
                ::comphelper::MimeConfigurationHelper aConfigHelper( m_xContext );
                OUString aEmbedFactory;
                if ( !aMediaType.isEmpty() )
                    aEmbedFactory = aConfigHelper.GetFactoryNameByMediaType( aMediaType );

                if ( aEmbedFactory.isEmpty() )
                    throw uno::RuntimeException(u"Failed to get OLE embedded object factory"_ustr);

                uno::Reference< uno::XInterface > xFact = m_xContext->getServiceManager()->createInstanceWithContext( aEmbedFactory, m_xContext );

                uno::Reference< embed::XEmbedObjectCreator > xEmbCreator( xFact, uno::UNO_QUERY_THROW );

                // now the object should be adjusted to become the wrapper
                nStep = 1;
                uno::Reference< lang::XComponent > xComp( m_xObjectStream, uno::UNO_QUERY_THROW );
                xComp->dispose();
                m_xObjectStream.clear();
                m_nObjectState = -1;

                nStep = 2;
                aTmpStreamName = MoveToTemporarySubstream();

                nStep = 3;
                m_xParentStorage->renameElement( aStorageName, m_aEntryName );

                nStep = 4;
                m_xWrappedObject.set( xEmbCreator->createInstanceInitFromEntry( m_xParentStorage, m_aEntryName, uno::Sequence< beans::PropertyValue >(), uno::Sequence< beans::PropertyValue >() ), uno::UNO_QUERY_THROW );

                // remember parent document name to show in the title bar
                m_xWrappedObject->setContainerName( m_aContainerName );

                bResult = true; // the change is no more revertable
                try
                {
                    m_xParentStorage->removeElement( aTmpStreamName );
                }
                catch( const uno::Exception& )
                {
                    // the success of the removing is not so important
                }
            }
        }
    }
    catch( const uno::Exception& )
    {
        // repair the object if necessary
        switch( nStep )
        {
            case 4:
            case 3:
            if ( !aTmpStreamName.isEmpty() && aTmpStreamName != m_aEntryName )
                try
                {
                    if ( m_xParentStorage->hasByName( m_aEntryName ) )
                        m_xParentStorage->removeElement( m_aEntryName );
                    m_xParentStorage->renameElement( aTmpStreamName, m_aEntryName );
                }
                catch ( const uno::Exception& ex )
                {
                    css::uno::Any anyEx = cppu::getCaughtException();
                    try {
                        close( true );
                    } catch( const uno::Exception& ) {}

                    m_xParentStorage->dispose(); // ??? the storage has information loss, it should be closed without committing!
                    throw css::lang::WrappedTargetRuntimeException( ex.Message,
                                    nullptr, anyEx ); // the repairing is not possible
                }
            [[fallthrough]];
            case 2:
                try
                {
                    m_xObjectStream = m_xParentStorage->openStreamElement( m_aEntryName, m_bReadOnly ? embed::ElementModes::READ : embed::ElementModes::READWRITE );
                    m_nObjectState = embed::EmbedStates::LOADED;
                }
                catch( const uno::Exception& ex )
                {
                    css::uno::Any anyEx = cppu::getCaughtException();
                    try {
                        close( true );
                    } catch( const uno::Exception& ) {}

                    throw css::lang::WrappedTargetRuntimeException( ex.Message,
                                    nullptr, anyEx ); // the repairing is not possible
                }
                [[fallthrough]];

            case 1:
            case 0:
                if ( !aStorageName.isEmpty() )
                    try {
                        m_xParentStorage->removeElement( aStorageName );
                    } catch( const uno::Exception& ) { SAL_WARN( "embeddedobj.ole", "Can not remove temporary storage!" ); }
                break;
        }
    }

    if ( bResult )
    {
        // the conversion was done successfully, now the additional initializations should happen

        MoveListeners();
        m_xWrappedObject->setClientSite( m_xClientSite );
        if ( m_xParent.is() )
        {
            uno::Reference< container::XChild > xChild( m_xWrappedObject, uno::UNO_QUERY );
            if ( xChild.is() )
                xChild->setParent( m_xParent );
        }

    }

    return bResult;
}


void SAL_CALL OleEmbeddedObject::changeState( sal_Int32 nNewState )
{
    if ( officecfg::Office::Common::Security::Scripting::DisableActiveContent::get()
         && nNewState != embed::EmbedStates::LOADED )
        throw embed::UnreachableStateException();
    // begin wrapping related part ====================
    uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
    if ( xWrappedObject.is() )
    {
        // the object was converted to OOo embedded object, the current implementation is now only a wrapper
        xWrappedObject->changeState( nNewState );
        return;
    }
    // end wrapping related part ====================

    ::osl::ResettableMutexGuard aGuard( m_aMutex );

    if ( m_bDisposed )
        throw lang::DisposedException(); // TODO

    if ( m_nObjectState == -1 )
        throw embed::WrongStateException( u"The object has no persistence!"_ustr,
                                        static_cast< ::cppu::OWeakObject* >(this) );

    // in case the object is already in requested state
    if ( m_nObjectState == nNewState )
        return;

#ifdef _WIN32
    if ( m_pOleComponent )
    {
        if ( m_nTargetState != -1 )
        {
            // means that the object is currently trying to reach the target state
            throw embed::StateChangeInProgressException( OUString(),
                                                        uno::Reference< uno::XInterface >(),
                                                        m_nTargetState );
        }

        TargetStateControl_Impl aControl( m_nTargetState, nNewState );

        // TODO: additional verbs can be a problem, since nobody knows how the object
        //       will behave after activation

        sal_Int32 nOldState = m_nObjectState;
        StateChangeNotification_Impl( true, nOldState, nNewState, aGuard );

        try
        {
            if ( nNewState == embed::EmbedStates::LOADED )
            {
                // This means just closing of the current object
                // If component can not be closed the object stays in loaded state
                // and it holds reference to "incomplete" component
                // If the object is switched to running state later
                // the component will become "complete"

                // the loaded state must be set before, because of notifications!
                m_nObjectState = nNewState;

                {
                    VerbExecutionControllerGuard aVerbGuard( m_aVerbExecutionController );
                    ExecUnlocked([p = m_pOleComponent] { p->CloseObject(); }, aGuard);
                }

                StateChangeNotification_Impl( false, nOldState, m_nObjectState, aGuard );
            }
            else if ( nNewState == embed::EmbedStates::RUNNING || nNewState == embed::EmbedStates::ACTIVE )
            {
                if ( m_nObjectState == embed::EmbedStates::LOADED )
                {
                    // if the target object is in loaded state and a different state is specified
                    // as a new one the object first must be switched to running state.

                    // the component can exist already in nonrunning state
                    // it can be created during loading to detect type of object
                    CreateOleComponentAndLoad_Impl( m_pOleComponent );

                    SwitchComponentToRunningState_Impl(aGuard);
                    m_nObjectState = embed::EmbedStates::RUNNING;
                    StateChangeNotification_Impl( false, nOldState, m_nObjectState, aGuard );

                    if ( m_pOleComponent && m_bHasSizeToSet )
                    {
                        try {
                            ExecUnlocked([p = m_pOleComponent, s = m_aSizeToSet,
                                          a = m_nAspectToSet]() { p->SetExtent(s, a); },
                                         aGuard);
                            m_bHasSizeToSet = false;
                        }
                        catch( const uno::Exception& ) {}
                    }

                    if ( m_nObjectState == nNewState )
                        return;
                }

                // so now the object is either switched from Active to Running state or viceversa
                // the notification about object state change will be done asynchronously
                if ( m_nObjectState == embed::EmbedStates::RUNNING && nNewState == embed::EmbedStates::ACTIVE )
                {
                    // execute OPEN verb, if object does not reach active state it is an object's problem
                    ExecUnlocked([p = m_pOleComponent]()
                                 { p->ExecuteVerb(embed::EmbedVerbs::MS_OLEVERB_OPEN); },
                                 aGuard);

                    // some objects do not allow to set the size even in running state
                    if ( m_pOleComponent && m_bHasSizeToSet )
                    {
                        try {
                            ExecUnlocked([p = m_pOleComponent, s = m_aSizeToSet,
                                          a = m_nAspectToSet]() { p->SetExtent(s, a); },
                                         aGuard);
                            m_bHasSizeToSet = false;
                        }
                        catch( uno::Exception& ) {}
                    }

                    m_nObjectState = nNewState;
                }
                else if ( m_nObjectState == embed::EmbedStates::ACTIVE && nNewState == embed::EmbedStates::RUNNING )
                {
                    ExecUnlocked(
                        [p = m_pOleComponent]()
                        {
                            p->CloseObject();
                            p->RunObject(); // Should not fail, the object already was active
                        },
                        aGuard);
                    m_nObjectState = nNewState;
                }
                else
                {
                    throw embed::UnreachableStateException();
                }
            }
            else
                throw embed::UnreachableStateException();
        }
        catch( uno::Exception& )
        {
            StateChangeNotification_Impl( false, nOldState, m_nObjectState, aGuard );
            throw;
        }
    }
    else
#endif
    {
        throw embed::UnreachableStateException();
    }
}


uno::Sequence< sal_Int32 > SAL_CALL OleEmbeddedObject::getReachableStates()
{
    // begin wrapping related part ====================
    uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
    if ( xWrappedObject.is() )
    {
        // the object was converted to OOo embedded object, the current implementation is now only a wrapper
        return xWrappedObject->getReachableStates();
    }
    // end wrapping related part ====================

    ::osl::ResettableMutexGuard aGuard( m_aMutex );
    if ( m_bDisposed )
        throw lang::DisposedException(); // TODO

    if ( m_nObjectState == -1 )
        throw embed::WrongStateException( u"The object has no persistence!"_ustr,
                                        static_cast< ::cppu::OWeakObject* >(this) );

#ifdef _WIN32
    if ( m_pOleComponent )
    {
        if ( m_nObjectState == embed::EmbedStates::LOADED )
        {
            // the list of supported verbs can be retrieved only when object is in running state
            throw embed::NeedsRunningStateException(); // TODO:
        }

        // the list of states can only be guessed based on standard verbs,
        // since there is no way to detect what additional verbs do
        // Pass m_pOleComponent to the lambda by copy, to make sure it doesn't depend on possible
        // destruction of 'this', while the lock is unset
        return GetReachableStatesList_Impl(
            ExecUnlocked([p = m_pOleComponent] { return p->GetVerbList(); }, aGuard));
    }
    else
#endif
    {
        return uno::Sequence< sal_Int32 >();
    }
}


sal_Int32 SAL_CALL OleEmbeddedObject::getCurrentState()
{
    // begin wrapping related part ====================
    uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
    if ( xWrappedObject.is() )
    {
        // the object was converted to OOo embedded object, the current implementation is now only a wrapper
        return xWrappedObject->getCurrentState();
    }
    // end wrapping related part ====================

    ::osl::MutexGuard aGuard( m_aMutex );
    if ( m_bDisposed )
        throw lang::DisposedException(); // TODO

    if ( m_nObjectState == -1 )
        throw embed::WrongStateException( u"The object has no persistence!"_ustr,
                                        static_cast< ::cppu::OWeakObject* >(this) );

    // TODO: Shouldn't we ask object? ( I guess no )
    return m_nObjectState;
}

namespace
{
    bool lcl_CopyStream(const uno::Reference<io::XInputStream>& xIn, const uno::Reference<io::XOutputStream>& xOut, sal_Int32 nMaxCopy = SAL_MAX_INT32)
    {
        if (nMaxCopy <= 0)
            return false;

        const sal_Int32 nChunkSize = 4096;
        uno::Sequence< sal_Int8 > aData(nChunkSize);
        sal_Int32 nTotalRead = 0;
        sal_Int32 nRead;
        do
        {
            if (nTotalRead + aData.getLength() > nMaxCopy)
            {
                aData.realloc(nMaxCopy - nTotalRead);
            }
            nRead = xIn->readBytes(aData, aData.getLength());
            nTotalRead += nRead;
            xOut->writeBytes(aData);
        } while (nRead == nChunkSize && nTotalRead <= nMaxCopy);
        return nTotalRead != 0;
    }

    uno::Reference < io::XStream > lcl_GetExtractedStream( OUString& rUrl,
        const css::uno::Reference< css::uno::XComponentContext >& xContext,
        const css::uno::Reference< css::io::XStream >& xObjectStream )
    {
        uno::Reference <io::XTempFile> xNativeTempFile(
            io::TempFile::create(xContext),
            uno::UNO_SET_THROW);
        uno::Reference < io::XStream > xStream(xNativeTempFile);

        uno::Sequence< uno::Any > aArgs{ uno::Any(xObjectStream),
                                         uno::Any(true) }; // do not create copy
        uno::Reference< container::XNameContainer > xNameContainer(
            xContext->getServiceManager()->createInstanceWithArgumentsAndContext(
                u"com.sun.star.embed.OLESimpleStorage"_ustr,
                aArgs, xContext ), uno::UNO_QUERY_THROW );

        //various stream names that can contain the real document contents for
        //this object in a straightforward direct way
        static const std::u16string_view aStreamNames[] =
        {
            u"CONTENTS",
            u"Package",
            u"EmbeddedOdf",
            u"WordDocument",
            u"Workbook",
            u"PowerPoint Document"
        };

        bool bCopied = false;
        for (size_t i = 0; i < std::size(aStreamNames) && !bCopied; ++i)
        {
            uno::Reference<io::XStream> xEmbeddedFile;
            try
            {
                xNameContainer->getByName(OUString(aStreamNames[i])) >>= xEmbeddedFile;
            }
            catch (const container::NoSuchElementException&)
            {
                // ignore
            }
            bCopied = xEmbeddedFile.is() && lcl_CopyStream(xEmbeddedFile->getInputStream(), xStream->getOutputStream());
        }

        if (!bCopied)
        {
            uno::Reference< io::XStream > xOle10Native;
            try
            {
                xNameContainer->getByName(u"\1Ole10Native"_ustr) >>= xOle10Native;
            }
            catch (container::NoSuchElementException const&)
            {
                // ignore
            }
            if (xOle10Native.is())
            {
                const uno::Reference<io::XInputStream> xIn = xOle10Native->getInputStream();
                xIn->skipBytes(4); //size of the entire stream minus 4 bytes
                xIn->skipBytes(2); //word that represent the directory type
                uno::Sequence< sal_Int8 > aData(1);
                sal_Int32 nRead;
                do
                {
                    nRead = xIn->readBytes(aData, 1);
                } while (nRead == 1 && aData[0] != 0);  // file name plus extension of the attachment null terminated
                do
                {
                    nRead = xIn->readBytes(aData, 1);
                } while (nRead == 1 && aData[0] != 0);  // Fully Qualified File name with extension
                xIn->skipBytes(1); //single byte
                xIn->skipBytes(1); //single byte
                xIn->skipBytes(2); //Word that represent the directory type
                xIn->skipBytes(4); //len of string
                do
                {
                    nRead = xIn->readBytes(aData, 1);
                } while (nRead == 1 && aData[0] != 0);  // Actual string representing the file path
                uno::Sequence< sal_Int8 > aLenData(4);
                xIn->readBytes(aLenData, 4); //len of attachment
                sal_uInt32 nLen = static_cast<sal_uInt32>(
                                              (aLenData[0] & 0xFF) |
                                              ((aLenData[1] & 0xFF) <<  8) |
                                              ((aLenData[2] & 0xFF) << 16) |
                                              ((aLenData[3] & 0xFF) << 24));

                bCopied = lcl_CopyStream(xIn, xStream->getOutputStream(), nLen);
            }
        }

        uno::Reference< io::XSeekable > xSeekableStor(xObjectStream, uno::UNO_QUERY);
        if (xSeekableStor.is())
            xSeekableStor->seek(0);

        if (!bCopied)
            bCopied = lcl_CopyStream(xObjectStream->getInputStream(), xStream->getOutputStream());

        if (bCopied)
        {
            xNativeTempFile->setRemoveFile(false);
            rUrl = xNativeTempFile->getUri();

            xNativeTempFile.clear();

            uno::Reference < ucb::XSimpleFileAccess3 > xSimpleFileAccess(
                    ucb::SimpleFileAccess::create( xContext ) );

            xSimpleFileAccess->setReadOnly(rUrl, true);
        }
        else
        {
            xNativeTempFile->setRemoveFile(true);
        }

        return xStream;
    }

    //Dump the objects content to a tempfile, just the "CONTENTS" stream if
    //there is one for non-compound documents, otherwise the whole content.
    //On success a file is returned which must be removed by the caller
    OUString lcl_ExtractObject(const css::uno::Reference< css::uno::XComponentContext >&&nbsp;xContext,
        const css::uno::Reference< css::io::XStream >& xObjectStream)
    {
        OUString sUrl;

        // the solution is only active for Unix systems
#ifndef _WIN32
        lcl_GetExtractedStream(sUrl, xContext, xObjectStream);
#else
        (void) xContext;
        (void) xObjectStream;
#endif
        return sUrl;
    }

    uno::Reference < io::XStream > lcl_ExtractObjectStream( const css::uno::Reference< css::uno::XComponentContext >& xContext,
        const css::uno::Reference< css::io::XStream >& xObjectStream )
    {
        OUString sUrl;
        return lcl_GetExtractedStream( sUrl, xContext, xObjectStream );
    }
}


void SAL_CALL OleEmbeddedObject::doVerb( sal_Int32 nVerbID )
{
    // begin wrapping related part ====================
    uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
    if ( xWrappedObject.is() )
    {
        // the object was converted to OOo embedded object, the current implementation is now only a wrapper
        xWrappedObject->doVerb(embed::EmbedVerbs::MS_OLEVERB_OPEN); // open content in the window not in-place
        return;
    }
    // end wrapping related part ====================

    ::osl::ResettableMutexGuard aGuard( m_aMutex );
    if ( m_bDisposed )
        throw lang::DisposedException(); // TODO

    if ( m_nObjectState == -1 )
        throw embed::WrongStateException( u"The object has no persistence!"_ustr,
                                        static_cast< ::cppu::OWeakObject* >(this) );

#ifdef _WIN32
    if ( m_pOleComponent )
    {
        sal_Int32 nOldState = m_nObjectState;

        // TODO/LATER detect target state here and do a notification
        // StateChangeNotification_Impl( sal_True, nOldState, nNewState );
        if ( m_nObjectState == embed::EmbedStates::LOADED )
        {
            // if the target object is in loaded state
            // it must be switched to running state to execute verb
            ExecUnlocked([this]() { changeState(embed::EmbedStates::RUNNING); }, aGuard);
        }

        try {
            if ( !m_pOleComponent )
                throw uno::RuntimeException("Null reference to OLE component");

            // ==== the STAMPIT related solution =============================
            m_aVerbExecutionController.StartControlExecution();

            ExecUnlocked(
                [nVerbID, p = m_pOleComponent, name = m_aContainerName]()
                {
                    p->ExecuteVerb(nVerbID);
                    p->SetHostName(name);
                },
                aGuard);

            // ==== the STAMPIT related solution =============================
            bool bModifiedOnExecution = m_aVerbExecutionController.EndControlExecution_WasModified();

            // this workaround is implemented for STAMPIT object
            // if object was modified during verb execution it is saved here
            if ( bModifiedOnExecution && m_pOleComponent->IsDirty() )
                SaveObject_Impl();

        }
        catch( uno::Exception& )
        {
            // ==== the STAMPIT related solution =============================
            m_aVerbExecutionController.EndControlExecution_WasModified();

            StateChangeNotification_Impl( false, nOldState, m_nObjectState, aGuard );
            throw;
        }

    }
    else
#endif
    {
        if ( nVerbID != -9 )
        {

            throw embed::UnreachableStateException();
        }

        // the workaround verb to show the object in case no server is available

        // if it is possible, the object will be converted to OOo format
        if ( !m_bTriedConversion )
        {
            m_bTriedConversion = true;
            if ( TryToConvertToOOo( m_xObjectStream ) )
            {
                aGuard.clear();
                changeState( embed::EmbedStates::ACTIVE );
                return;
            }
        }

        if ( !m_xOwnView.is() && m_xObjectStream.is() && m_aFilterName != "Text" )
        {
            try {
                uno::Reference< io::XSeekable > xSeekable( m_xObjectStream, uno::UNO_QUERY );
                if ( xSeekable.is() )
                    xSeekable->seek( 0 );

                m_xOwnView = new OwnView_Impl( m_xContext, m_xObjectStream->getInputStream() );
            }
            catch( uno::RuntimeException& )
            {
                throw;
            }
            catch (uno::Exception const&)
            {
                TOOLS_WARN_EXCEPTION("embeddedobj.ole", "OleEmbeddedObject::doVerb: -9 fallback path:");
            }
        }

        // it may be the OLE Storage, try to extract stream
        if ( !m_xOwnView.is() && m_xObjectStream.is() && m_aFilterName == "Text" )
        {
            uno::Reference< io::XStream > xStream = lcl_ExtractObjectStream( m_xContext, m_xObjectStream );

            if ( TryToConvertToOOo( xStream ) )
            {
                aGuard.clear();
                changeState( embed::EmbedStates::ACTIVE );
                return;
            }
        }

        if (!m_xOwnView.is() || !m_xOwnView->Open())
        {
            //Make a RO copy and see if the OS can find something to at
            //least display the content for us
            if (m_aTempDumpURL.isEmpty())
                m_aTempDumpURL = lcl_ExtractObject(m_xContext, m_xObjectStream);

            if (m_aTempDumpURL.isEmpty())
                throw embed::UnreachableStateException();

            uno::Reference< css::system::XSystemShellExecute > xSystemShellExecute(
                css::system::SystemShellExecute::create( m_xContext ) );
            xSystemShellExecute->execute(m_aTempDumpURL, OUString(), css::system::SystemShellExecuteFlags::URIS_ONLY);

        }

    }
}


uno::Sequence< embed::VerbDescriptor > SAL_CALL OleEmbeddedObject::getSupportedVerbs()
{
    // begin wrapping related part ====================
    uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
    if ( xWrappedObject.is() )
    {
        // the object was converted to OOo embedded object, the current implementation is now only a wrapper
        return xWrappedObject->getSupportedVerbs();
    }
    // end wrapping related part ====================

    osl::ClearableMutexGuard aGuard(m_aMutex);
    if ( m_bDisposed )
        throw lang::DisposedException(); // TODO

    if ( m_nObjectState == -1 )
        throw embed::WrongStateException( u"The object has no persistence!"_ustr,
                                        static_cast< ::cppu::OWeakObject* >(this) );
#ifdef _WIN32
    if ( m_pOleComponent )
    {
        // registry could be used in this case
        // if ( m_nObjectState == embed::EmbedStates::LOADED )
        // {
        //  // the list of supported verbs can be retrieved only when object is in running state
        //  throw embed::NeedsRunningStateException(); // TODO:
        // }

        aGuard.clear();
        return m_pOleComponent->GetVerbList();
    }
    else
#endif
    {
        // tdf#140079 Claim support for the OleEmbeddedObject::doVerb -9 fallback.
        // So in SfxViewFrame::GetState_Impl in case SID_OBJECT hasVerbs is not
        // empty, so that the doVerb attempt with -9 fallback is attempted
        uno::Sequence<embed::VerbDescriptor> aRet(1);
        aRet.getArray()[0].VerbID = -9;
        return aRet;
    }
}


void SAL_CALL OleEmbeddedObject::setClientSite(
                const uno::Reference< embed::XEmbeddedClient >& xClient )
{
    // begin wrapping related part ====================
    uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
    if ( xWrappedObject.is() )
    {
        // the object was converted to OOo embedded object, the current implementation is now only a wrapper
        xWrappedObject->setClientSite( xClient );
        return;
    }
    // end wrapping related part ====================

    ::osl::MutexGuard aGuard( m_aMutex );
    if ( m_bDisposed )
        throw lang::DisposedException(); // TODO

    if ( m_xClientSite != xClient)
    {
        if ( m_nObjectState != embed::EmbedStates::LOADED && m_nObjectState != embed::EmbedStates::RUNNING )
            throw embed::WrongStateException(
                                    u"The client site can not be set currently!"_ustr,
                                    static_cast< ::cppu::OWeakObject* >(this) );

        m_xClientSite = xClient;
    }
}


uno::Reference< embed::XEmbeddedClient > SAL_CALL OleEmbeddedObject::getClientSite()
{
    // begin wrapping related part ====================
    uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
    if ( xWrappedObject.is() )
    {
        // the object was converted to OOo embedded object, the current implementation is now only a wrapper
        return xWrappedObject->getClientSite();
    }
    // end wrapping related part ====================

    ::osl::MutexGuard aGuard( m_aMutex );
    if ( m_bDisposed )
        throw lang::DisposedException(); // TODO

    if ( m_nObjectState == -1 )
        throw embed::WrongStateException( u"The object has no persistence!"_ustr,
                                        static_cast< ::cppu::OWeakObject* >(this) );

    return m_xClientSite;
}


void SAL_CALL OleEmbeddedObject::update()
{
    // begin wrapping related part ====================
    uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
    if ( xWrappedObject.is() )
    {
        // the object was converted to OOo embedded object, the current implementation is now only a wrapper
        xWrappedObject->update();
        return;
    }
    // end wrapping related part ====================

    ::osl::MutexGuard aGuard( m_aMutex );
    if ( m_bDisposed )
        throw lang::DisposedException(); // TODO

    if ( m_nObjectState == -1 )
        throw embed::WrongStateException( u"The object has no persistence!"_ustr,
                                        static_cast< ::cppu::OWeakObject* >(this) );

    if ( m_nUpdateMode == embed::EmbedUpdateModes::EXPLICIT_UPDATE )
    {
        // TODO: update view representation
    }
    else
    {
        // the object must be up to date
        SAL_WARN_IF( m_nUpdateMode != embed::EmbedUpdateModes::ALWAYS_UPDATE, "embeddedobj.ole", "Unknown update mode!" );
    }
}


void SAL_CALL OleEmbeddedObject::setUpdateMode( sal_Int32 nMode )
{
    // begin wrapping related part ====================
    uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
    if ( xWrappedObject.is() )
    {
        // the object was converted to OOo embedded object, the current implementation is now only a wrapper
        xWrappedObject->setUpdateMode( nMode );
        return;
    }
    // end wrapping related part ====================

    ::osl::MutexGuard aGuard( m_aMutex );
    if ( m_bDisposed )
        throw lang::DisposedException(); // TODO

    if ( m_nObjectState == -1 )
        throw embed::WrongStateException( u"The object has no persistence!"_ustr,
                                       static_cast< ::cppu::OWeakObject* >(this) );

    OSL_ENSURE( nMode == embed::EmbedUpdateModes::ALWAYS_UPDATE
                    || nMode == embed::EmbedUpdateModes::EXPLICIT_UPDATE,
                "Unknown update mode!" );
    m_nUpdateMode = nMode;
}


sal_Int64 SAL_CALL OleEmbeddedObject::getStatus( sal_Int64
    nAspect
)
{
    // begin wrapping related part ====================
    uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
    if ( xWrappedObject.is() )
    {
        // the object was converted to OOo embedded object, the current implementation is now only a wrapper
        return xWrappedObject->getStatus( nAspect );
    }
    // end wrapping related part ====================

    osl::ResettableMutexGuard aGuard(m_aMutex);
    if ( m_bDisposed )
        throw lang::DisposedException(); // TODO

    if ( m_nObjectState == -1 )
        throw embed::WrongStateException( u"The object must be in running state!"_ustr,
                                    static_cast< ::cppu::OWeakObject* >(this) );

    sal_Int64 nResult = 0;

#ifdef _WIN32
    if ( m_bGotStatus && m_nStatusAspect == nAspect )
        nResult = m_nStatus;
    else if ( m_pOleComponent )
    {
        m_nStatus = ExecUnlocked([p = m_pOleComponent, nAspect] { return p->GetMiscStatus(nAspect); }, aGuard);
        m_nStatusAspect = nAspect;
        m_bGotStatus = true;
        nResult = m_nStatus;
    }
#endif

    // this implementation needs size to be provided after object loading/creating to work in optimal way
    return ( nResult | embed::EmbedMisc::EMBED_NEEDSSIZEONLOAD );
}


void SAL_CALL OleEmbeddedObject::setContainerName( const OUString& sName )
{
    // begin wrapping related part ====================
    uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
    if ( xWrappedObject.is() )
    {
        // the object was converted to OOo embedded object, the current implementation is now only a wrapper
        xWrappedObject->setContainerName( sName );
        return;
    }
    // end wrapping related part ====================

    ::osl::MutexGuard aGuard( m_aMutex );
    if ( m_bDisposed )
        throw lang::DisposedException(); // TODO

    m_aContainerName = sName;
}


/* vim:set shiftwidth=4 softtabstop=4 expandtab: */