oox/source/ole/olestorage.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <oox/ole/olestorage.hxx>
  21
  22 #include <com/sun/star/beans/PropertyValue.hpp>
  23 #include <com/sun/star/container/XNameContainer.hpp>
  24 #include <com/sun/star/embed/XTransactedObject.hpp>
  25 #include <com/sun/star/io/IOException.hpp>
  26 #include <com/sun/star/io/NotConnectedException.hpp>
  27 #include <com/sun/star/io/TempFile.hpp>
  28 #include <com/sun/star/io/XInputStream.hpp>
  29 #include <com/sun/star/io/XOutputStream.hpp>
  30 #include <com/sun/star/io/XSeekable.hpp>
  31 #include <com/sun/star/io/XStream.hpp>
  32 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  33 #include <com/sun/star/uno/XComponentContext.hpp>
  34 #include <cppuhelper/implbase.hxx>
  35 #include <osl/diagnose.h>
  36 #include <oox/helper/binaryinputstream.hxx>
  37 #include <oox/helper/binaryoutputstream.hxx>
  38 #include <oox/helper/containerhelper.hxx>
  39 #include <oox/helper/helper.hxx>
  40
  41 namespace oox {
  42 namespace ole {
  43
  44 using namespace ::com::sun::star::beans;
  45 using namespace ::com::sun::star::container;
  46 using namespace ::com::sun::star::embed;
  47 using namespace ::com::sun::star::io;
  48 using namespace ::com::sun::star::lang;
  49 using namespace ::com::sun::star::uno;
  50
  51 namespace {
  52
  53 /** Implementation of an OLE storage output stream that inserts itself into the
  54     storage when it is closed.
  55  */
  56 class OleOutputStream : public ::cppu::WeakImplHelper< XSeekable, XOutputStream >
  57 {
  58 public:
  59     explicit            OleOutputStream(
  60                             const Reference< XComponentContext >& rxContext,
  61                             const Reference< XNameContainer >& rxStorage,
  62                             const OUString& rElementName );
  63
  64     virtual void SAL_CALL seek( sal_Int64 nPos ) override;
  65     virtual sal_Int64 SAL_CALL getPosition() override;
  66     virtual sal_Int64 SAL_CALL getLength() override;
  67
  68     virtual void SAL_CALL writeBytes( const Sequence< sal_Int8 >& rData ) override;
  69     virtual void SAL_CALL flush() override;
  70     virtual void SAL_CALL closeOutput() override;
  71
  72 private:
  73     /// @throws IOException
  74     void                ensureSeekable() const;
  75     /// @throws NotConnectedException
  76     void                ensureConnected() const;
  77
  78 private:
  79     Reference< XNameContainer > mxStorage;
  80     Reference< XStream > mxTempFile;
  81     Reference< XOutputStream > mxOutStrm;
  82     Reference< XSeekable > mxSeekable;
  83     OUString const      maElementName;
  84 };
  85
  86 OleOutputStream::OleOutputStream( const Reference< XComponentContext >& rxContext,
  87         const Reference< XNameContainer >& rxStorage, const OUString& rElementName ) :
  88     mxStorage( rxStorage ),
  89     maElementName( rElementName )
  90 {
  91     try
  92     {
  93         mxTempFile.set( TempFile::create(rxContext), UNO_QUERY_THROW );
  94         mxOutStrm = mxTempFile->getOutputStream();
  95         mxSeekable.set( mxOutStrm, UNO_QUERY );
  96     }
  97     catch(const Exception& )
  98     {
  99     }
 100 }
 101
 102 void SAL_CALL OleOutputStream::seek( sal_Int64 nPos )
 103 {
 104     ensureSeekable();
 105     mxSeekable->seek( nPos );
 106 }
 107
 108 sal_Int64 SAL_CALL OleOutputStream::getPosition()
 109 {
 110     ensureSeekable();
 111     return mxSeekable->getPosition();
 112 }
 113
 114 sal_Int64 SAL_CALL OleOutputStream::getLength()
 115 {
 116     ensureSeekable();
 117     return mxSeekable->getLength();
 118 }
 119
 120 void SAL_CALL OleOutputStream::writeBytes( const Sequence< sal_Int8 >& rData )
 121 {
 122     ensureConnected();
 123     mxOutStrm->writeBytes( rData );
 124 }
 125
 126 void SAL_CALL OleOutputStream::flush()
 127 {
 128     ensureConnected();
 129     mxOutStrm->flush();
 130 }
 131
 132 void SAL_CALL OleOutputStream::closeOutput()
 133 {
 134     ensureConnected();
 135     ensureSeekable();
 136     // remember the class members
 137     Reference< XOutputStream > xOutStrm = mxOutStrm;
 138     Reference< XSeekable > xSeekable = mxSeekable;
 139     // reset all class members
 140     mxOutStrm.clear();
 141     mxSeekable.clear();
 142     // close stream (and let it throw something if needed)
 143     xOutStrm->closeOutput();
 144     // on success, insert the stream into the OLE storage (must be seek-ed back before)
 145     xSeekable->seek( 0 );
 146     if( !ContainerHelper::insertByName( mxStorage, maElementName, Any( mxTempFile ) ) )
 147         throw IOException();
 148 }
 149
 150 void OleOutputStream::ensureSeekable() const
 151 {
 152     if( !mxSeekable.is() )
 153         throw IOException();
 154 }
 155
 156 void OleOutputStream::ensureConnected() const
 157 {
 158     if( !mxOutStrm.is() )
 159         throw NotConnectedException();
 160 }
 161
 162 } // namespace
 163
 164 OleStorage::OleStorage( const Reference< XComponentContext >& rxContext,
 165         const Reference< XInputStream >& rxInStream, bool bBaseStreamAccess ) :
 166     StorageBase( rxInStream, bBaseStreamAccess ),
 167     mxContext( rxContext ),
 168     mpParentStorage( nullptr )
 169 {
 170     OSL_ENSURE( mxContext.is(), "OleStorage::OleStorage - missing component context" );
 171     initStorage( rxInStream );
 172 }
 173
 174 OleStorage::OleStorage( const Reference< XComponentContext >& rxContext,
 175         const Reference< XStream >& rxOutStream, bool bBaseStreamAccess ) :
 176     StorageBase( rxOutStream, bBaseStreamAccess ),
 177     mxContext( rxContext ),
 178     mpParentStorage( nullptr )
 179 {
 180     OSL_ENSURE( mxContext.is(), "OleStorage::OleStorage - missing component context" );
 181     initStorage( rxOutStream );
 182 }
 183
 184 OleStorage::OleStorage( const OleStorage& rParentStorage,
 185         const Reference< XNameContainer >& rxStorage, const OUString& rElementName, bool bReadOnly ) :
 186     StorageBase( rParentStorage, rElementName, bReadOnly ),
 187     mxContext( rParentStorage.mxContext ),
 188     mxStorage( rxStorage ),
 189     mpParentStorage( &rParentStorage )
 190 {
 191     OSL_ENSURE( mxStorage.is(), "OleStorage::OleStorage - missing substorage elements" );
 192 }
 193
 194 OleStorage::OleStorage( const OleStorage& rParentStorage,
 195         const Reference< XStream >& rxOutStream, const OUString& rElementName ) :
 196     StorageBase( rParentStorage, rElementName, false ),
 197     mxContext( rParentStorage.mxContext ),
 198     mpParentStorage( &rParentStorage )
 199 {
 200     initStorage( rxOutStream );
 201 }
 202
 203 OleStorage::~OleStorage()
 204 {
 205 }
 206
 207 void OleStorage::initStorage( const Reference< XInputStream >& rxInStream )
 208 {
 209     // if stream is not seekable, create temporary copy
 210     Reference< XInputStream > xInStrm = rxInStream;
 211     if( !Reference< XSeekable >( xInStrm, UNO_QUERY ).is() ) try
 212     {
 213         Reference< XStream > xTempFile( TempFile::create(mxContext), UNO_QUERY_THROW );
 214         {
 215             Reference< XOutputStream > xOutStrm( xTempFile->getOutputStream(), UNO_SET_THROW );
 216             /*  Pass false to both binary stream objects to keep the UNO
 217                 streams alive. Life time of these streams is controlled by the
 218                 tempfile implementation. */
 219             BinaryXOutputStream aOutStrm( xOutStrm, false );
 220             BinaryXInputStream aInStrm( xInStrm, false );
 221             aInStrm.copyToStream( aOutStrm );
 222         } // scope closes output stream of tempfile
 223         xInStrm = xTempFile->getInputStream();
 224     }
 225     catch(const Exception& )
 226     {
 227         OSL_FAIL( "OleStorage::initStorage - cannot create temporary copy of input stream" );
 228     }
 229
 230     // create base storage object
 231     if( xInStrm.is() ) try
 232     {
 233         Reference< XMultiServiceFactory > xFactory( mxContext->getServiceManager(), UNO_QUERY_THROW );
 234         Sequence< Any > aArgs( 2 );
 235         aArgs[ 0 ] <<= xInStrm;
 236         aArgs[ 1 ] <<= true;        // true = do not create a copy of the input stream
 237         mxStorage.set( xFactory->createInstanceWithArguments("com.sun.star.embed.OLESimpleStorage", aArgs ), UNO_QUERY_THROW );
 238     }
 239     catch(const Exception& )
 240     {
 241     }
 242 }
 243
 244 void OleStorage::initStorage( const Reference< XStream >& rxOutStream )
 245 {
 246     // create base storage object
 247     if( rxOutStream.is() ) try
 248     {
 249         Reference< XMultiServiceFactory > xFactory( mxContext->getServiceManager(), UNO_QUERY_THROW );
 250         Sequence< Any > aArgs( 2 );
 251         aArgs[ 0 ] <<= rxOutStream;
 252         aArgs[ 1 ] <<= true;        // true = do not create a copy of the stream
 253         mxStorage.set( xFactory->createInstanceWithArguments("com.sun.star.embed.OLESimpleStorage", aArgs ), UNO_QUERY_THROW );
 254     }
 255     catch(const Exception& )
 256     {
 257     }
 258 }
 259
 260 // StorageBase interface ------------------------------------------------------
 261
 262 bool OleStorage::implIsStorage() const
 263 {
 264     if( mxStorage.is() ) try
 265     {
 266         /*  If this is not an OLE storage, hasElements() of the OLESimpleStorage
 267             implementation throws an exception. But we do not return the result
 268             of hasElements(), because an empty storage is a valid storage too. */
 269         (void)mxStorage->hasElements();
 270         return true;
 271     }
 272     catch(const Exception& )
 273     {
 274     }
 275     return false;
 276 }
 277
 278 Reference< XStorage > OleStorage::implGetXStorage() const
 279 {
 280     OSL_FAIL( "OleStorage::getXStorage - not implemented" );
 281     return Reference< XStorage >();
 282 }
 283
 284 void OleStorage::implGetElementNames( ::std::vector< OUString >& orElementNames ) const
 285 {
 286     Sequence< OUString > aNames;
 287     if( mxStorage.is() ) try
 288     {
 289         aNames = mxStorage->getElementNames();
 290         if( aNames.hasElements() )
 291             orElementNames.insert( orElementNames.end(), aNames.begin(), aNames.end() );
 292     }
 293     catch(const Exception& )
 294     {
 295     }
 296 }
 297
 298 StorageRef OleStorage::implOpenSubStorage( const OUString& rElementName, bool bCreateMissing )
 299 {
 300     StorageRef xSubStorage;
 301     if( mxStorage.is() && !rElementName.isEmpty() )
 302     {
 303         try
 304         {
 305             Reference< XNameContainer > xSubElements( mxStorage->getByName( rElementName ), UNO_QUERY_THROW );
 306             xSubStorage.reset( new OleStorage( *this, xSubElements, rElementName, true ) );
 307         }
 308         catch(const Exception& )
 309         {
 310         }
 311
 312         /*  The OLESimpleStorage API implementation seems to be buggy in the
 313             area of writable inplace substorage (sometimes it overwrites other
 314             unrelated streams with zero bytes). We go the save way and create a
 315             new OLE storage based on a temporary file. All operations are
 316             performed on this clean storage. On committing, the storage will be
 317             completely re-inserted into the parent storage. */
 318         if( !isReadOnly() && (bCreateMissing || xSubStorage.get()) ) try
 319         {
 320             // create new storage based on a temp file
 321             Reference< XStream > xTempFile( TempFile::create(mxContext), UNO_QUERY_THROW );
 322             StorageRef xTempStorage( new OleStorage( *this, xTempFile, rElementName ) );
 323             // copy existing substorage into temp storage
 324             if( xSubStorage.get() )
 325                 xSubStorage->copyStorageToStorage( *xTempStorage );
 326             // return the temp storage to caller
 327             xSubStorage = xTempStorage;
 328         }
 329         catch(const Exception& )
 330         {
 331         }
 332     }
 333     return xSubStorage;
 334 }
 335
 336 Reference< XInputStream > OleStorage::implOpenInputStream( const OUString& rElementName )
 337 {
 338     Reference< XInputStream > xInStream;
 339     if( mxStorage.is() ) try
 340     {
 341         xInStream.set( mxStorage->getByName( rElementName ), UNO_QUERY );
 342     }
 343     catch(const Exception& )
 344     {
 345     }
 346     return xInStream;
 347 }
 348
 349 Reference< XOutputStream > OleStorage::implOpenOutputStream( const OUString& rElementName )
 350 {
 351     Reference< XOutputStream > xOutStream;
 352     if( mxStorage.is() && !rElementName.isEmpty() )
 353         xOutStream.set( new OleOutputStream( mxContext, mxStorage, rElementName ) );
 354     return xOutStream;
 355 }
 356
 357 void OleStorage::implCommit() const
 358 {
 359     try
 360     {
 361         // commit this storage (finalizes the file this storage is based on)
 362         Reference< XTransactedObject >( mxStorage, UNO_QUERY_THROW )->commit();
 363         // re-insert this storage into the parent storage
 364         if( mpParentStorage )
 365         {
 366             if( mpParentStorage->mxStorage->hasByName( getName() ) )
 367             {
 368                 // replaceByName() does not work (#i109539#)
 369                 mpParentStorage->mxStorage->removeByName( getName() );
 370                 Reference< XTransactedObject >( mpParentStorage->mxStorage, UNO_QUERY_THROW )->commit();
 371             }
 372             mpParentStorage->mxStorage->insertByName( getName(), Any( mxStorage ) );
 373             // this requires another commit(), which will be performed by the parent storage
 374         }
 375     }
 376     catch(const Exception& )
 377     {
 378     }
 379 }
 380
 381 } // namespace ole
 382 } // namespace oox
 383
 384 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */