diff options
Diffstat (limited to 'oox/source/ole/vbaproject.cxx')
| -rw-r--r-- | oox/source/ole/vbaproject.cxx | 564 |
1 files changed, 564 insertions, 0 deletions
diff --git a/oox/source/ole/vbaproject.cxx b/oox/source/ole/vbaproject.cxx new file mode 100644 index 000000000..c868d83b6 --- /dev/null +++ b/oox/source/ole/vbaproject.cxx @@ -0,0 +1,564 @@ +/* -*- 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 <oox/ole/vbaproject.hxx> + +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/document/XStorageBasedDocument.hpp> +#include <com/sun/star/embed/ElementModes.hpp> +#include <com/sun/star/embed/XTransactedObject.hpp> +#include <com/sun/star/frame/XModel.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/script/ModuleType.hpp> +#include <com/sun/star/script/XLibraryContainer.hpp> +#include <com/sun/star/script/vba/XVBACompatibility.hpp> +#include <com/sun/star/script/vba/XVBAMacroResolver.hpp> +#include <com/sun/star/uno/XComponentContext.hpp> +#include <comphelper/configurationhelper.hxx> +#include <comphelper/documentinfo.hxx> +#include <comphelper/storagehelper.hxx> +#include <osl/diagnose.h> +#include <rtl/tencinfo.h> +#include <sal/log.hxx> +#include <oox/helper/binaryinputstream.hxx> +#include <oox/helper/propertyset.hxx> +#include <oox/helper/textinputstream.hxx> +#include <oox/ole/olestorage.hxx> +#include <oox/ole/vbacontrol.hxx> +#include <oox/ole/vbahelper.hxx> +#include <oox/ole/vbainputstream.hxx> +#include <oox/ole/vbamodule.hxx> +#include <oox/token/properties.hxx> + +namespace oox::ole { + +using namespace ::com::sun::star; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::document; +using namespace ::com::sun::star::embed; +using namespace ::com::sun::star::frame; +using namespace ::com::sun::star::io; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::script; +using namespace ::com::sun::star::script::vba; +using namespace ::com::sun::star::uno; + +using ::comphelper::ConfigurationHelper; + +namespace { + +bool lclReadConfigItem( const Reference< XInterface >& rxConfigAccess, const OUString& rItemName ) +{ + // some applications do not support all configuration items, assume 'false' in this case + try + { + Any aItem = ConfigurationHelper::readRelativeKey( rxConfigAccess, "Filter/Import/VBA", rItemName ); + return aItem.has< bool >() && aItem.get< bool >(); + } + catch(const Exception& ) + { + } + return false; +} + +} // namespace + +VbaFilterConfig::VbaFilterConfig( const Reference< XComponentContext >& rxContext, std::u16string_view rConfigCompName ) +{ + OSL_ENSURE( rxContext.is(), "VbaFilterConfig::VbaFilterConfig - missing component context" ); + if( rxContext.is() ) try + { + OSL_ENSURE( !rConfigCompName.empty(), "VbaFilterConfig::VbaFilterConfig - invalid configuration component name" ); + OUString aConfigPackage = OUString::Concat("org.openoffice.Office.") + rConfigCompName; + mxConfigAccess = ConfigurationHelper::openConfig( rxContext, aConfigPackage, comphelper::EConfigurationModes::ReadOnly ); + } + catch(const Exception& ) + { + } + OSL_ENSURE( mxConfigAccess.is(), "VbaFilterConfig::VbaFilterConfig - cannot open configuration" ); +} + +VbaFilterConfig::~VbaFilterConfig() +{ +} + +bool VbaFilterConfig::isImportVba() const +{ + return lclReadConfigItem( mxConfigAccess, "Load" ); +} + +bool VbaFilterConfig::isImportVbaExecutable() const +{ + return lclReadConfigItem( mxConfigAccess, "Executable" ); +} + +bool VbaFilterConfig::isExportVba() const +{ + return lclReadConfigItem( mxConfigAccess, "Save" ); +} + +VbaMacroAttacherBase::VbaMacroAttacherBase( const OUString& rMacroName ) : + maMacroName( rMacroName ) +{ + OSL_ENSURE( !maMacroName.isEmpty(), "VbaMacroAttacherBase::VbaMacroAttacherBase - empty macro name" ); +} + +VbaMacroAttacherBase::~VbaMacroAttacherBase() +{ +} + +void VbaMacroAttacherBase::resolveAndAttachMacro( const Reference< XVBAMacroResolver >& rxResolver ) +{ + try + { + attachMacro( rxResolver->resolveVBAMacroToScriptURL( maMacroName ) ); + } + catch(const Exception& ) + { + } +} + +VbaProject::VbaProject( const Reference< XComponentContext >& rxContext, + const Reference< XModel >& rxDocModel, std::u16string_view rConfigCompName ) : + VbaFilterConfig( rxContext, rConfigCompName ), + mxContext( rxContext ), + mxDocModel( rxDocModel ), + maPrjName( "Standard" ) +{ + OSL_ENSURE( mxContext.is(), "VbaProject::VbaProject - missing component context" ); + OSL_ENSURE( mxDocModel.is(), "VbaProject::VbaProject - missing document model" ); +} + +VbaProject::~VbaProject() +{ +} + +bool VbaProject::importVbaProject( StorageBase& rVbaPrjStrg ) +{ + // create GraphicHelper + Reference< css::frame::XFrame > xFrame; + if ( mxDocModel.is() ) + { + Reference< css::frame::XController > xController = mxDocModel->getCurrentController(); + xFrame = xController.is() ? xController->getFrame() : nullptr; + } + StorageRef noStorage; + // if the GraphicHelper tries to use noStorage it will of course crash + // but... this shouldn't happen as there is no reason for GraphicHelper + // to do that when importing VBA projects + GraphicHelper grfHlp( mxContext, xFrame, noStorage ); + importVbaProject( rVbaPrjStrg, grfHlp ); + // return true if something has been imported + return (mxBasicLib.is() && mxBasicLib->hasElements()) || + (mxDialogLib.is() && mxDialogLib->hasElements()); +} + +void VbaProject::importVbaProject( StorageBase& rVbaPrjStrg, const GraphicHelper& rGraphicHelper ) +{ + if( rVbaPrjStrg.isStorage() ) + { + // load the code modules and forms + if( isImportVba() ) + importVba( rVbaPrjStrg, rGraphicHelper ); + // copy entire storage into model + if( isExportVba() ) + copyStorage( rVbaPrjStrg ); + } +} + +void VbaProject::importVbaData(const uno::Reference<io::XInputStream>& xInputStream) +{ + uno::Reference<document::XStorageBasedDocument> xStorageBasedDoc(mxDocModel, uno::UNO_QUERY); + uno::Reference<embed::XStorage> xDocStorage = xStorageBasedDoc->getDocumentStorage(); + { + const sal_Int32 nOpenMode = ElementModes::SEEKABLE | ElementModes::WRITE | ElementModes::TRUNCATE; + uno::Reference<io::XOutputStream> xDocStream(xDocStorage->openStreamElement("_MS_VBA_Macros_XML", nOpenMode), uno::UNO_QUERY); + comphelper::OStorageHelper::CopyInputToOutput(xInputStream, xDocStream); + } + uno::Reference<embed::XTransactedObject>(xDocStorage, uno::UNO_QUERY_THROW)->commit(); +} + +void VbaProject::registerMacroAttacher( const VbaMacroAttacherRef& rxAttacher ) +{ + OSL_ENSURE( rxAttacher, "VbaProject::registerMacroAttacher - unexpected empty reference" ); + maMacroAttachers.push_back( rxAttacher ); +} + +// protected ------------------------------------------------------------------ + +void VbaProject::addDummyModule( const OUString& rName, sal_Int32 nType ) +{ + OSL_ENSURE( !rName.isEmpty(), "VbaProject::addDummyModule - missing module name" ); + maDummyModules[ rName ] = nType; +} + +void VbaProject::prepareImport() +{ +} + +// private -------------------------------------------------------------------- + +Reference< XLibraryContainer > VbaProject::getLibraryContainer( sal_Int32 nPropId ) +{ + PropertySet aDocProp( mxDocModel ); + Reference< XLibraryContainer > xLibContainer( aDocProp.getAnyProperty( nPropId ), UNO_QUERY ); + return xLibContainer; +} + +Reference< XNameContainer > VbaProject::openLibrary( sal_Int32 nPropId ) +{ + Reference< XNameContainer > xLibrary; + try + { + Reference< XLibraryContainer > xLibContainer( getLibraryContainer( nPropId ), UNO_SET_THROW ); + if( !xLibContainer->hasByName( maPrjName ) ) + xLibContainer->createLibrary( maPrjName ); + xLibrary.set( xLibContainer->getByName( maPrjName ), UNO_QUERY_THROW ); + } + catch(const Exception& ) + { + } + OSL_ENSURE( xLibrary.is(), "VbaProject::openLibrary - cannot create library" ); + return xLibrary; +} + +Reference< XNameContainer > const & VbaProject::createBasicLibrary() +{ + if( !mxBasicLib.is() ) + mxBasicLib = openLibrary( PROP_BasicLibraries ); + return mxBasicLib; +} + +Reference< XNameContainer > const & VbaProject::createDialogLibrary() +{ + if( !mxDialogLib.is() ) + mxDialogLib = openLibrary( PROP_DialogLibraries ); + return mxDialogLib; +} + +void VbaProject::importVba( StorageBase& rVbaPrjStrg, const GraphicHelper& rGraphicHelper ) +{ + readVbaModules( rVbaPrjStrg ); + importModulesAndForms(rVbaPrjStrg, rGraphicHelper ); + // attach macros to registered objects + attachMacros(); +} + +void VbaProject::readVbaModules( StorageBase& rVbaPrjStrg ) +{ + StorageRef xVbaStrg = rVbaPrjStrg.openSubStorage( "VBA", false ); + OSL_ENSURE( xVbaStrg, "VbaProject::readVbaModules - cannot open 'VBA' substorage" ); + if( !xVbaStrg ) + return; + + /* Read the 'VBA/dir' stream which contains general settings of the VBA + project such as the text encoding used throughout several streams, and + a list of all code modules. + */ + BinaryXInputStream aInStrm( xVbaStrg->openInputStream( "dir" ), true ); + // VbaInputStream implements decompression + VbaInputStream aDirStrm( aInStrm ); + OSL_ENSURE( !aDirStrm.isEof(), "VbaProject::importVba - cannot open 'dir' stream" ); + if( aDirStrm.isEof() ) + return; + + // virtual call, derived classes may do some preparations + prepareImport(); + + // read all records of the directory + rtl_TextEncoding eTextEnc = RTL_TEXTENCODING_MS_1252; + sal_uInt16 nModuleCount = 0; + bool bExecutable = isImportVbaExecutable(); + + sal_uInt16 nRecId = 0; + StreamDataSequence aRecData; + while( VbaHelper::readDirRecord( nRecId, aRecData, aDirStrm ) && (nRecId != VBA_ID_PROJECTEND) ) + { + // create record stream object from imported record data + SequenceInputStream aRecStrm( aRecData ); + sal_Int32 nRecSize = aRecData.getLength(); + switch( nRecId ) + { + case VBA_ID_PROJECTCODEPAGE: + { + OSL_ENSURE( nRecSize == 2, "VbaProject::importVba - invalid record size" ); + OSL_ENSURE( maModules.empty(), "VbaProject::importVba - unexpected PROJECTCODEPAGE record" ); + rtl_TextEncoding eNewTextEnc = rtl_getTextEncodingFromWindowsCodePage( aRecStrm.readuInt16() ); + OSL_ENSURE( eNewTextEnc != RTL_TEXTENCODING_DONTKNOW, "VbaProject::importVba - unknown text encoding" ); + if( eNewTextEnc != RTL_TEXTENCODING_DONTKNOW ) + eTextEnc = eNewTextEnc; + } + break; + case VBA_ID_PROJECTNAME: + { + OUString aPrjName = aRecStrm.readCharArrayUC( nRecSize, eTextEnc ); + OSL_ENSURE( !aPrjName.isEmpty(), "VbaProject::importVba - invalid project name" ); + if( !aPrjName.isEmpty() ) + maPrjName = aPrjName; + } + break; + case VBA_ID_PROJECTMODULES: + OSL_ENSURE( nRecSize == 2, "VbaProject::importVba - invalid record size" ); + OSL_ENSURE( maModules.empty(), "VbaProject::importVba - unexpected PROJECTMODULES record" ); + nModuleCount = aRecStrm.readuInt16(); + break; + case VBA_ID_MODULENAME: + { + OUString aName = aRecStrm.readCharArrayUC( nRecSize, eTextEnc ); + OSL_ENSURE( !aName.isEmpty(), "VbaProject::importVba - invalid module name" ); + OSL_ENSURE( !maModules.has( aName ), "VbaProject::importVba - multiple modules with the same name" ); + VbaModuleMap::mapped_type& rxModule = maModules[ aName ]; + rxModule = std::make_shared<VbaModule>( mxContext, mxDocModel, aName, eTextEnc, bExecutable ); + // read all remaining records until the MODULEEND record + rxModule->importDirRecords( aDirStrm ); + OSL_ENSURE( !maModulesByStrm.has( rxModule->getStreamName() ), "VbaProject::importVba - multiple modules with the same stream name" ); + maModulesByStrm[ rxModule->getStreamName() ] = rxModule; + } + break; + } + } + SAL_WARN_IF( nModuleCount != maModules.size(), "oox", "VbaProject::importVba - invalid module count" ); + + /* The directory does not contain the real type of the modules, it + distinguishes only between 'procedural' and 'document' (the latter + includes class and form modules). Now, the exact type of all modules + will be read from the 'PROJECT' stream. It consists of text lines in + 'key=value' format which list the code modules by type. + + - The line 'document=<modulename>/&HXXXXXXXX' declares document + modules. These are attached to the Word document (usually called + 'ThisDocument'), the Excel workbook (usually called + 'ThisWorkbook'), or single Excel worksheets or chartsheets (usually + called 'SheetX' or 'ChartX', X being a decimal number). Of course, + users may rename all these modules. The slash character separates + an automation server version number (hexadecimal 'XXXXXXXX') from + the module name. + - The line 'Module=<modulename>' declares common procedural code + modules. + - The line 'Class=<modulename>' declares a class module. + - The line 'BaseClass=<modulename>' declares a code module attached + to a user form with the same name. + */ + BinaryXInputStream aPrjStrm( rVbaPrjStrg.openInputStream( "PROJECT" ), true ); + OSL_ENSURE( !aPrjStrm.isEof(), "VbaProject::importVba - cannot open 'PROJECT' stream" ); + // do not exit if this stream does not exist, but proceed to load the modules below + if( !aPrjStrm.isEof() ) + { + TextInputStream aPrjTextStrm( mxContext, aPrjStrm, eTextEnc ); + OUString aKey, aValue; + bool bExitLoop = false; + while( !bExitLoop && !aPrjTextStrm.isEof() ) + { + // read a text line from the stream + OUString aLine = aPrjTextStrm.readLine().trim(); + sal_Int32 nLineLen = aLine.getLength(); + // exit if a subsection starts (section name is given in brackets) + bExitLoop = (nLineLen >= 2) && (aLine[ 0 ] == '[') && (aLine[ nLineLen - 1 ] == ']'); + if( !bExitLoop && VbaHelper::extractKeyValue( aKey, aValue, aLine ) ) + { + sal_Int32 nType = ModuleType::UNKNOWN; + if( aKey.equalsIgnoreAsciiCase( "Document" ) ) + { + nType = ModuleType::DOCUMENT; + // strip automation server version from module names + sal_Int32 nSlashPos = aValue.indexOf( '/' ); + if( nSlashPos >= 0 ) + aValue = aValue.copy( 0, nSlashPos ); + } + else if( aKey.equalsIgnoreAsciiCase( "Module" ) ) + nType = ModuleType::NORMAL; + else if( aKey.equalsIgnoreAsciiCase( "Class" ) ) + nType = ModuleType::CLASS; + else if( aKey.equalsIgnoreAsciiCase( "BaseClass" ) ) + nType = ModuleType::FORM; + + if( (nType != ModuleType::UNKNOWN) && !aValue.isEmpty() ) + { + OSL_ENSURE( maModules.has( aValue ), "VbaProject::importVba - module not found" ); + if( VbaModule* pModule = maModules.get( aValue ).get() ) + pModule->setType( nType ); + } + } + } + } + + if( maModules.empty() ) + return; + + try + { + /* Set library container to VBA compatibility mode. This will create + the VBA Globals object and store it in the Basic manager of the + document. */ + try + { + Reference< XVBACompatibility > xVBACompat( getLibraryContainer( PROP_BasicLibraries ), UNO_QUERY_THROW ); + xVBACompat->setVBACompatibilityMode( true ); + xVBACompat->setProjectName( maPrjName ); + + uno::Reference<beans::XPropertySet> xProps(xVBACompat, uno::UNO_QUERY_THROW); + xProps->setPropertyValue("VBATextEncoding", uno::Any(eTextEnc)); + } + catch(const Exception& ) + { + } + } + catch(const Exception& ) + { + } +} + +void VbaProject::importModulesAndForms( StorageBase& rVbaPrjStrg, const GraphicHelper& rGraphicHelper ) +{ + StorageRef xVbaStrg = rVbaPrjStrg.openSubStorage( "VBA", false ); + OSL_ENSURE( xVbaStrg, "VbaProject::importModulesAndForms - cannot open 'VBA' substorage" ); + if( !xVbaStrg ) + return; + rtl_TextEncoding eTextEnc = RTL_TEXTENCODING_MS_1252; + bool bExecutable = isImportVbaExecutable(); + + // create empty dummy modules + VbaModuleMap aDummyModules; + for (auto const& dummyModule : maDummyModules) + { + OSL_ENSURE( !maModules.has( dummyModule.first ) && !aDummyModules.has( dummyModule.first ), "VbaProject::importVba - multiple modules with the same name" ); + VbaModuleMap::mapped_type& rxModule = aDummyModules[ dummyModule.first ]; + rxModule = std::make_shared<VbaModule>( mxContext, mxDocModel, dummyModule.first, eTextEnc, bExecutable ); + rxModule->setType( dummyModule.second ); + } + + /* Now it is time to load the source code. All modules will be inserted + into the Basic library of the document specified by the 'maPrjName' + member. Do not create the Basic library, if there are no modules + specified. */ + if( !maModules.empty() || !aDummyModules.empty() ) try + { + // get the model factory and the basic library + Reference< XMultiServiceFactory > xModelFactory( mxDocModel, UNO_QUERY_THROW ); + Reference< XNameContainer > xBasicLib( createBasicLibrary(), UNO_SET_THROW ); + + // try to get access to document objects related to code modules + Reference< XNameAccess > xDocObjectNA; + try + { + xDocObjectNA.set( xModelFactory->createInstance( "ooo.vba.VBAObjectModuleObjectProvider" ), UNO_QUERY ); + } + catch(const Exception& ) + { + // not all documents support this + } + + if( xBasicLib.is() ) + { + // #TODO cater for mxOleOverridesSink, like I used to before + // call Basic source code import for each module, std::[c]ref enforces pass-by-ref + maModules.forEachMem( &VbaModule::createAndImportModule, + ::std::ref( *xVbaStrg ), ::std::cref( xBasicLib ), + ::std::cref( xDocObjectNA ) ); + + // create empty dummy modules + aDummyModules.forEachMem( &VbaModule::createEmptyModule, + ::std::cref( xBasicLib ), ::std::cref( xDocObjectNA ) ); + } + } + catch(const Exception& ) + { + } + + /* Load the forms. The file format specification requires that a module + must exist for every form. We are a bit more tolerant and scan the + project storage for all form substorages. This may 'repair' broken VBA + storages that misses to mention a module for an existing form. */ + ::std::vector< OUString > aElements; + rVbaPrjStrg.getElementNames( aElements ); + for (auto const& elem : aElements) + { + // try to open the element as storage + if( elem != "VBA" ) + { + StorageRef xSubStrg = rVbaPrjStrg.openSubStorage( elem, false ); + if( xSubStrg ) try + { + // resolve module name from storage name (which equals the module stream name) + VbaModule* pModule = maModulesByStrm.get( elem ).get(); + OSL_ENSURE( pModule && (pModule->getType() == ModuleType::FORM), + "VbaProject::importVba - form substorage without form module" ); + OUString aModuleName; + if( pModule ) + aModuleName = pModule->getName(); + + // create and import the form + Reference< XNameContainer > xDialogLib( createDialogLibrary(), UNO_SET_THROW ); + VbaUserForm aForm( mxContext, mxDocModel, rGraphicHelper, true/*bDefaultColorBgr*/ ); + aForm.importForm( xDialogLib, *xSubStrg, aModuleName, eTextEnc ); + } + catch(const Exception& ) + { + } + } + } +} + +void VbaProject::attachMacros() +{ + if( maMacroAttachers.empty() || !mxContext.is() ) + return; + + try + { + comphelper::DocumentInfo::notifyMacroEventRead(mxDocModel); + + Reference< XMultiComponentFactory > xFactory( mxContext->getServiceManager(), UNO_SET_THROW ); + Sequence< Any > aArgs{ Any(mxDocModel), Any(maPrjName) }; + Reference< XVBAMacroResolver > xResolver( xFactory->createInstanceWithArgumentsAndContext( + "com.sun.star.script.vba.VBAMacroResolver", aArgs, mxContext ), UNO_QUERY_THROW ); + maMacroAttachers.forEachMem( &VbaMacroAttacherBase::resolveAndAttachMacro, ::std::cref( xResolver ) ); + + } + catch(const Exception& ) + { + } +} + +void VbaProject::copyStorage( StorageBase& rVbaPrjStrg ) +{ + if( !mxContext.is() ) + return; + + try + { + Reference< XStorageBasedDocument > xStorageBasedDoc( mxDocModel, UNO_QUERY_THROW ); + Reference< XStorage > xDocStorage( xStorageBasedDoc->getDocumentStorage(), UNO_SET_THROW ); + { + const sal_Int32 nOpenMode = ElementModes::SEEKABLE | ElementModes::WRITE | ElementModes::TRUNCATE; + Reference< XStream > xDocStream( xDocStorage->openStreamElement( "_MS_VBA_Macros", nOpenMode ), UNO_SET_THROW ); + OleStorage aDestStorage( mxContext, xDocStream, false ); + rVbaPrjStrg.copyStorageToStorage( aDestStorage ); + aDestStorage.commit(); + } + Reference< XTransactedObject >( xDocStorage, UNO_QUERY_THROW )->commit(); + } + catch(const Exception& ) + { + } +} + +} // namespace oox + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |