ucb/source/ucp/tdoc/tdoc_storage.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29
  30 /**************************************************************************
  31                                 TODO
  32  **************************************************************************
  33
  34  - remove root storage access workaround
  35
  36  *************************************************************************/
  37
  38 #define ROOTSTORAGE_ACCESS_WORKAROUND 1
  39
  40 #include <memory>
  41
  42 #include "com/sun/star/beans/XPropertySet.hpp"
  43 #include "com/sun/star/embed/ElementModes.hpp"
  44 #include "com/sun/star/lang/XSingleServiceFactory.hpp"
  45
  46 #include "tdoc_uri.hxx"
  47 #include "tdoc_docmgr.hxx"
  48 #include "tdoc_stgelems.hxx"
  49
  50 #include "tdoc_storage.hxx"
  51
  52 using namespace com::sun::star;
  53 using namespace tdoc_ucp;
  54
  55
  56 //=========================================================================
  57 //=========================================================================
  58 //
  59 // StorageElementFactory Implementation.
  60 //
  61 //=========================================================================
  62 //=========================================================================
  63
  64 StorageElementFactory::StorageElementFactory(
  65     const uno::Reference< lang::XMultiServiceFactory > & xSMgr,
  66     const rtl::Reference< OfficeDocumentsManager > & xDocsMgr )
  67 : m_xDocsMgr( xDocsMgr ),
  68   m_xSMgr( xSMgr )
  69 {
  70 }
  71
  72 //=========================================================================
  73 StorageElementFactory::~StorageElementFactory()
  74 {
  75     OSL_ENSURE( m_aMap.empty(),
  76         "StorageElementFactory::~StorageElementFactory - Dangling storages!" );
  77 }
  78
  79 //=========================================================================
  80 uno::Reference< embed::XStorage >
  81 StorageElementFactory::createTemporaryStorage()
  82     throw ( uno::Exception,
  83             uno::RuntimeException )
  84 {
  85     uno::Reference< embed::XStorage > xStorage;
  86     uno::Reference< lang::XSingleServiceFactory > xStorageFac;
  87     if ( m_xSMgr.is() )
  88     {
  89         xStorageFac = uno::Reference< lang::XSingleServiceFactory >(
  90                m_xSMgr->createInstance(
  91                    rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
  92                        "com.sun.star.embed.StorageFactory" ) ) ),
  93                uno::UNO_QUERY );
  94     }
  95
  96     OSL_ENSURE( xStorageFac.is(), "Can't create storage factory!" );
  97     if ( xStorageFac.is() )
  98         xStorage = uno::Reference< embed::XStorage >(
  99                             xStorageFac->createInstance(),
 100                             uno::UNO_QUERY );
 101
 102     if ( !xStorage.is() )
 103         throw uno::RuntimeException();
 104
 105     return xStorage;
 106 }
 107
 108 //=========================================================================
 109 uno::Reference< embed::XStorage >
 110 StorageElementFactory::createStorage( const rtl::OUString & rUri,
 111                                       StorageAccessMode eMode )
 112     throw ( embed::InvalidStorageException,
 113             lang::IllegalArgumentException,
 114             io::IOException,
 115             embed::StorageWrappedTargetException,
 116             uno::RuntimeException )
 117 {
 118     osl::MutexGuard aGuard( m_aMutex );
 119
 120     if ( ( eMode != READ ) &&
 121          ( eMode != READ_WRITE_NOCREATE ) &&
 122          ( eMode != READ_WRITE_CREATE ) )
 123         throw lang::IllegalArgumentException(
 124             rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
 125                 "Invalid open mode!" ) ),
 126             uno::Reference< uno::XInterface >(),
 127             sal_Int16( 2 ) );
 128
 129     Uri aUri( rUri );
 130     if ( aUri.isRoot() )
 131     {
 132         throw lang::IllegalArgumentException(
 133             rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
 134                 "Root never has a storage!" ) ),
 135             uno::Reference< uno::XInterface >(),
 136             sal_Int16( 1 ) );
 137     }
 138
 139     rtl::OUString aUriKey
 140         ( ( rUri.getStr()[ rUri.getLength() - 1 ] == sal_Unicode( '/' ) )
 141           ? rUri.copy( 0, rUri.getLength() - 1 )
 142           : rUri );
 143
 144     StorageMap::iterator aIt ( m_aMap.begin() );
 145     StorageMap::iterator aEnd( m_aMap.end() );
 146
 147     while ( aIt != aEnd )
 148     {
 149         if ( (*aIt).first.first == aUriKey )
 150         {
 151             // URI matches. Now, check open mode.
 152             bool bMatch = true;
 153             switch ( eMode )
 154             {
 155                 case READ:
 156                     // No need to check; storage is at least readable.
 157                     bMatch = true;
 158                     break;
 159
 160                 case READ_WRITE_NOCREATE:
 161                 case READ_WRITE_CREATE:
 162                     // If found storage is writable, it can be used.
 163                     // If not, a new one must be created.
 164                     bMatch = (*aIt).first.second;
 165                     break;
 166             }
 167
 168             if ( bMatch )
 169                 break;
 170         }
 171         ++aIt;
 172     }
 173
 174     if ( aIt == aEnd )
 175     {
 176         uno::Reference< embed::XStorage > xParentStorage;
 177
 178         // documents never have a parent storage.
 179         if ( !aUri.isDocument() )
 180         {
 181             xParentStorage = queryParentStorage( aUriKey, eMode );
 182
 183             if ( !xParentStorage.is() )
 184             {
 185                 // requested to create new storage, but failed?
 186                 OSL_ENSURE( eMode != READ_WRITE_CREATE,
 187                             "Unable to create parent storage!" );
 188                 return xParentStorage;
 189             }
 190         }
 191
 192         uno::Reference< embed::XStorage > xStorage
 193             = queryStorage( xParentStorage, aUriKey, eMode );
 194
 195         if ( !xStorage.is() )
 196         {
 197             // requested to create new storage, but failed?
 198             OSL_ENSURE( eMode != READ_WRITE_CREATE,
 199                         "Unable to create storage!" );
 200             return xStorage;
 201         }
 202
 203         bool bWritable = ( ( eMode == READ_WRITE_NOCREATE )
 204                             || ( eMode == READ_WRITE_CREATE ) );
 205
 206         std::auto_ptr< Storage > xElement(
 207             new Storage( m_xSMgr, this, aUriKey, xParentStorage, xStorage ) );
 208
 209         aIt = m_aMap.insert(
 210             StorageMap::value_type(
 211                 std::pair< rtl::OUString, bool >( aUriKey, bWritable ),
 212                 xElement.get() ) ).first;
 213
 214         aIt->second->m_aContainerIt = aIt;
 215         xElement.release();
 216         return aIt->second;
 217     }
 218     else if ( osl_incrementInterlockedCount( &aIt->second->m_refCount ) > 1 )
 219     {
 220         rtl::Reference< Storage > xElement( aIt->second );
 221         osl_decrementInterlockedCount( &aIt->second->m_refCount );
 222         return aIt->second;
 223     }
 224     else
 225     {
 226         osl_decrementInterlockedCount( &aIt->second->m_refCount );
 227         aIt->second->m_aContainerIt = m_aMap.end();
 228
 229         uno::Reference< embed::XStorage > xParentStorage;
 230
 231         // documents never have a parent storage.
 232         if ( !aUri.isDocument() )
 233         {
 234             xParentStorage = queryParentStorage( aUriKey, eMode );
 235
 236             if ( !xParentStorage.is() )
 237             {
 238                 // requested to create new storage, but failed?
 239                 OSL_ENSURE( eMode != READ_WRITE_CREATE,
 240                             "Unable to create parent storage!" );
 241                 return xParentStorage;
 242             }
 243         }
 244
 245         uno::Reference< embed::XStorage > xStorage
 246             = queryStorage( xParentStorage, aUriKey, eMode );
 247
 248         if ( !xStorage.is() )
 249         {
 250             // requested to create new storage, but failed?
 251             OSL_ENSURE( eMode != READ_WRITE_CREATE,
 252                         "Unable to create storage!" );
 253             return xStorage;
 254         }
 255
 256         aIt->second
 257             = new Storage( m_xSMgr, this, aUriKey, xParentStorage, xStorage );
 258         aIt->second->m_aContainerIt = aIt;
 259         return aIt->second;
 260     }
 261 }
 262
 263 //=========================================================================
 264 uno::Reference< io::XInputStream >
 265 StorageElementFactory::createInputStream( const rtl::OUString & rUri,
 266                                           const rtl::OUString & rPassword )
 267     throw ( embed::InvalidStorageException,
 268             lang::IllegalArgumentException,
 269             io::IOException,
 270             embed::StorageWrappedTargetException,
 271             packages::WrongPasswordException,
 272             uno::RuntimeException )
 273 {
 274     osl::MutexGuard aGuard( m_aMutex );
 275
 276     uno::Reference< embed::XStorage > xParentStorage
 277         = queryParentStorage( rUri, READ );
 278
 279     // Each stream must have a parent storage.
 280     if ( !xParentStorage.is() )
 281         return uno::Reference< io::XInputStream >();
 282
 283     uno::Reference< io::XStream > xStream
 284         = queryStream( xParentStorage, rUri, rPassword, READ, false );
 285
 286     if ( !xStream.is() )
 287         return uno::Reference< io::XInputStream >();
 288
 289     return xStream->getInputStream();
 290 }
 291
 292 //=========================================================================
 293 uno::Reference< io::XOutputStream >
 294 StorageElementFactory::createOutputStream( const rtl::OUString & rUri,
 295                                            const rtl::OUString & rPassword,
 296                                            bool bTruncate )
 297     throw ( embed::InvalidStorageException,
 298             lang::IllegalArgumentException,
 299             io::IOException,
 300             embed::StorageWrappedTargetException,
 301             packages::WrongPasswordException,
 302             uno::RuntimeException )
 303 {
 304     osl::MutexGuard aGuard( m_aMutex );
 305
 306     uno::Reference< embed::XStorage > xParentStorage
 307         = queryParentStorage( rUri, READ_WRITE_CREATE );
 308
 309     // Each stream must have a parent storage.
 310     if ( !xParentStorage.is() )
 311     {
 312         OSL_FAIL( "StorageElementFactory::createOutputStream - "
 313                     "Unable to create parent storage!" );
 314         return uno::Reference< io::XOutputStream >();
 315     }
 316
 317     uno::Reference< io::XStream > xStream
 318         = queryStream(
 319             xParentStorage, rUri, rPassword, READ_WRITE_CREATE, bTruncate );
 320
 321     if ( !xStream.is() )
 322     {
 323         OSL_FAIL( "StorageElementFactory::createOutputStream - "
 324                     "Unable to create stream!" );
 325         return uno::Reference< io::XOutputStream >();
 326     }
 327
 328     // Note: We need a wrapper to hold a reference to the parent storage to
 329     //       ensure that nobody else owns it at the moment we want to commit
 330     //       our changes. (There can be only one writable instance at a time
 331     //       and even no writable instance if there is  already another
 332     //       read-only instance!)
 333     return uno::Reference< io::XOutputStream >(
 334         new OutputStream(
 335             m_xSMgr, rUri, xParentStorage, xStream->getOutputStream() ) );
 336 }
 337
 338 //=========================================================================
 339 uno::Reference< io::XStream >
 340 StorageElementFactory::createStream( const rtl::OUString & rUri,
 341                                      const rtl::OUString & rPassword,
 342                                      bool bTruncate )
 343     throw ( embed::InvalidStorageException,
 344             lang::IllegalArgumentException,
 345             io::IOException,
 346             embed::StorageWrappedTargetException,
 347             packages::WrongPasswordException,
 348             uno::RuntimeException )
 349 {
 350     osl::MutexGuard aGuard( m_aMutex );
 351
 352     uno::Reference< embed::XStorage > xParentStorage
 353         = queryParentStorage( rUri, READ_WRITE_CREATE );
 354
 355     // Each stream must have a parent storage.
 356     if ( !xParentStorage.is() )
 357     {
 358         OSL_FAIL( "StorageElementFactory::createStream - "
 359                     "Unable to create parent storage!" );
 360         return uno::Reference< io::XStream >();
 361     }
 362
 363     uno::Reference< io::XStream > xStream
 364         = queryStream(
 365             xParentStorage, rUri, rPassword, READ_WRITE_NOCREATE, bTruncate );
 366
 367     if ( !xStream.is() )
 368     {
 369         OSL_FAIL( "StorageElementFactory::createStream - "
 370                     "Unable to create stream!" );
 371         return uno::Reference< io::XStream >();
 372     }
 373
 374     return uno::Reference< io::XStream >(
 375         new Stream( m_xSMgr, rUri, xParentStorage, xStream ) );
 376 }
 377
 378 //=========================================================================
 379 void StorageElementFactory::releaseElement( Storage * pElement ) SAL_THROW(())
 380 {
 381     OSL_ASSERT( pElement );
 382     osl::MutexGuard aGuard( m_aMutex );
 383     if ( pElement->m_aContainerIt != m_aMap.end() )
 384         m_aMap.erase( pElement->m_aContainerIt );
 385 }
 386
 387 //=========================================================================
 388 //
 389 // Non-UNO interface
 390 //
 391 //=========================================================================
 392
 393 uno::Reference< embed::XStorage > StorageElementFactory::queryParentStorage(
 394         const rtl::OUString & rUri, StorageAccessMode eMode )
 395     throw ( embed::InvalidStorageException,
 396             lang::IllegalArgumentException,
 397             io::IOException,
 398             embed::StorageWrappedTargetException,
 399             uno::RuntimeException )
 400 {
 401     uno::Reference< embed::XStorage > xParentStorage;
 402
 403     Uri aUri( rUri );
 404     Uri aParentUri( aUri.getParentUri() );
 405     if ( !aParentUri.isRoot() )
 406     {
 407         xParentStorage = createStorage( aUri.getParentUri(), eMode );
 408         OSL_ENSURE( xParentStorage.is()
 409                     // requested to create new storage, but failed?
 410                     || ( eMode != READ_WRITE_CREATE ),
 411                     "StorageElementFactory::queryParentStorage - No storage!" );
 412     }
 413     return xParentStorage;
 414 }
 415
 416 //=========================================================================
 417 uno::Reference< embed::XStorage > StorageElementFactory::queryStorage(
 418         const uno::Reference< embed::XStorage > & xParentStorage,
 419         const rtl::OUString & rUri,
 420         StorageAccessMode eMode )
 421     throw ( embed::InvalidStorageException,
 422             lang::IllegalArgumentException,
 423             io::IOException,
 424             embed::StorageWrappedTargetException,
 425             uno::RuntimeException )
 426 {
 427     uno::Reference< embed::XStorage > xStorage;
 428
 429     Uri aUri( rUri );
 430
 431     if ( !xParentStorage.is() )
 432     {
 433         // document storage
 434
 435         xStorage = m_xDocsMgr->queryStorage( aUri.getDocumentId() );
 436
 437         if ( !xStorage.is() )
 438         {
 439             if ( eMode == READ_WRITE_CREATE )
 440                 throw lang::IllegalArgumentException(
 441                     rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
 442                         "Invalid open mode: document storages cannot be "
 443                         "created!" ) ),
 444                     uno::Reference< uno::XInterface >(),
 445                     sal_Int16( 2 ) );
 446             else
 447                 throw embed::InvalidStorageException(
 448                     rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
 449                         "Invalid document id!" ) ),
 450                     uno::Reference< uno::XInterface >() );
 451         }
 452
 453         // match xStorage's open mode against requested open mode
 454
 455         uno::Reference< beans::XPropertySet > xPropSet(
 456             xStorage, uno::UNO_QUERY );
 457         OSL_ENSURE( xPropSet.is(),
 458                     "StorageElementFactory::queryStorage - "
 459                     "No XPropertySet interface!" );
 460         try
 461         {
 462             uno::Any aPropValue = xPropSet->getPropertyValue(
 463                 rtl::OUString(
 464                     RTL_CONSTASCII_USTRINGPARAM( "OpenMode" ) ) );
 465
 466             sal_Int32 nOpenMode = 0;
 467             if ( aPropValue >>= nOpenMode )
 468             {
 469                 switch ( eMode )
 470                 {
 471                     case READ:
 472                         if ( !( nOpenMode & embed::ElementModes::READ ) )
 473                         {
 474                             // document opened, but not readable.
 475                             throw embed::InvalidStorageException(
 476                                 rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
 477                                     "Storage is open, but not readable!" ) ),
 478                                 uno::Reference< uno::XInterface >() );
 479                         }
 480                         // storage okay
 481                         break;
 482
 483                     case READ_WRITE_NOCREATE:
 484                     case READ_WRITE_CREATE:
 485                         if ( !( nOpenMode & embed::ElementModes::WRITE ) )
 486                         {
 487                             // document opened, but not writable.
 488                             throw embed::InvalidStorageException(
 489                                 rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
 490                                     "Storage is open, but not writable!" ) ),
 491                                 uno::Reference< uno::XInterface >() );
 492                         }
 493                         // storage okay
 494                         break;
 495                 }
 496             }
 497             else
 498             {
 499                 OSL_FAIL(
 500                     "Bug! Value of property OpenMode has wrong type!" );
 501
 502                 throw uno::RuntimeException(
 503                     rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
 504                         "Bug! Value of property OpenMode has wrong type!" ) ),
 505                     uno::Reference< uno::XInterface >() );
 506             }
 507         }
 508         catch ( beans::UnknownPropertyException const & e )
 509         {
 510             OSL_FAIL( "Property OpenMode not supported!" );
 511
 512             throw embed::StorageWrappedTargetException(
 513                     rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
 514                         "Bug! Value of property OpenMode has wrong type!" ) ),
 515                     uno::Reference< uno::XInterface >(),
 516                     uno::makeAny( e ) );
 517         }
 518         catch ( lang::WrappedTargetException const & e )
 519         {
 520             OSL_FAIL( "Caught WrappedTargetException!" );
 521
 522             throw embed::StorageWrappedTargetException(
 523                     rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
 524                         "WrappedTargetException during getPropertyValue!" ) ),
 525                     uno::Reference< uno::XInterface >(),
 526                     uno::makeAny( e ) );
 527         }
 528     }
 529     else
 530     {
 531         // sub storage
 532
 533         const rtl::OUString & rName = aUri.getDecodedName();
 534
 535         if ( eMode == READ )
 536         {
 537             try
 538             {
 539                 sal_Int32 nOpenMode = embed::ElementModes::READ
 540                                       | embed::ElementModes::NOCREATE;
 541                 xStorage
 542                     = xParentStorage->openStorageElement( rName, nOpenMode );
 543             }
 544             catch ( io::IOException const & )
 545             {
 546                 // Another chance: Try to clone storage.
 547                 xStorage = createTemporaryStorage();
 548                 xParentStorage->copyStorageElementLastCommitTo( rName,
 549                                                                 xStorage );
 550             }
 551         }
 552         else
 553         {
 554             sal_Int32 nOpenMode = embed::ElementModes::READWRITE;
 555             if ( eMode == READ_WRITE_NOCREATE )
 556                 nOpenMode |= embed::ElementModes::NOCREATE;
 557
 558             xStorage = xParentStorage->openStorageElement( rName, nOpenMode );
 559         }
 560     }
 561
 562     OSL_ENSURE( xStorage.is() || ( eMode != READ_WRITE_CREATE ),
 563                 "StorageElementFactory::queryStorage - No storage!" );
 564     return xStorage;
 565 }
 566
 567 //=========================================================================
 568 uno::Reference< io::XStream >
 569 StorageElementFactory::queryStream(
 570                 const uno::Reference< embed::XStorage > & xParentStorage,
 571                 const rtl::OUString & rUri,
 572                 const rtl::OUString & rPassword,
 573                 StorageAccessMode eMode,
 574                 bool bTruncate )
 575     throw ( embed::InvalidStorageException,
 576             lang::IllegalArgumentException,
 577             io::IOException,
 578             embed::StorageWrappedTargetException,
 579             packages::WrongPasswordException,
 580             uno::RuntimeException )
 581 {
 582     osl::MutexGuard aGuard( m_aMutex );
 583
 584     if ( !xParentStorage.is() )
 585     {
 586         throw lang::IllegalArgumentException(
 587             rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
 588                 "No parent storage!" ) ),
 589             uno::Reference< uno::XInterface >(),
 590             sal_Int16( 2 ) );
 591     }
 592
 593     Uri aUri( rUri );
 594     if ( aUri.isRoot() )
 595     {
 596         throw lang::IllegalArgumentException(
 597             rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
 598                 "Root never is a stream!" ) ),
 599             uno::Reference< uno::XInterface >(),
 600             sal_Int16( 2 ) );
 601     }
 602     else if ( aUri.isDocument() )
 603     {
 604         throw lang::IllegalArgumentException(
 605             rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
 606                 "A document never is a stream!" ) ),
 607             uno::Reference< uno::XInterface >(),
 608             sal_Int16( 2 ) );
 609     }
 610
 611     sal_Int32 nOpenMode;
 612     switch ( eMode )
 613     {
 614         case READ:
 615             nOpenMode = embed::ElementModes::READ
 616                         | embed::ElementModes::NOCREATE
 617                         | embed::ElementModes::SEEKABLE;
 618             break;
 619
 620         case READ_WRITE_NOCREATE:
 621             nOpenMode = embed::ElementModes::READWRITE
 622                         | embed::ElementModes::NOCREATE
 623                         | embed::ElementModes::SEEKABLE;
 624
 625             if ( bTruncate )
 626                 nOpenMode |= embed::ElementModes::TRUNCATE;
 627
 628             break;
 629
 630         case READ_WRITE_CREATE:
 631             nOpenMode = embed::ElementModes::READWRITE
 632                         | embed::ElementModes::SEEKABLE;
 633
 634             if ( bTruncate )
 635                 nOpenMode |= embed::ElementModes::TRUNCATE;
 636
 637             break;
 638
 639         default:
 640             OSL_FAIL( "StorageElementFactory::queryStream : Unknown open mode!" );
 641
 642             throw embed::InvalidStorageException(
 643                 rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
 644                     "Unknown open mode!" ) ),
 645                 uno::Reference< uno::XInterface >() );
 646     }
 647
 648     // No object re-usage mechanism; streams are seekable => not stateless.
 649
 650     uno::Reference< io::XStream > xStream;
 651     if ( !rPassword.isEmpty() )
 652     {
 653         if ( eMode == READ )
 654         {
 655             try
 656             {
 657                 xStream = xParentStorage->cloneEncryptedStreamElement(
 658                                                          aUri.getDecodedName(),
 659                                                          rPassword );
 660             }
 661             catch ( packages::NoEncryptionException const & )
 662             {
 663                 xStream
 664                     = xParentStorage->cloneStreamElement( aUri.getDecodedName() );
 665             }
 666         }
 667         else
 668         {
 669             try
 670             {
 671                 xStream = xParentStorage->openEncryptedStreamElement(
 672                                                          aUri.getDecodedName(),
 673                                                          nOpenMode,
 674                                                          rPassword );
 675             }
 676             catch ( packages::NoEncryptionException const & )
 677             {
 678                 xStream
 679                     = xParentStorage->openStreamElement( aUri.getDecodedName(),
 680                                                          nOpenMode );
 681             }
 682         }
 683     }
 684     else
 685     {
 686         if ( eMode == READ )
 687         {
 688             xStream = xParentStorage->cloneStreamElement( aUri.getDecodedName() );
 689         }
 690         else
 691         {
 692             xStream = xParentStorage->openStreamElement( aUri.getDecodedName(),
 693                                                          nOpenMode );
 694         }
 695     }
 696
 697     if ( !xStream.is() )
 698     {
 699         throw embed::InvalidStorageException(
 700             rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
 701                 "No stream!" ) ),
 702             uno::Reference< uno::XInterface >() );
 703     }
 704
 705     return xStream;
 706 }
 707
 708 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */