svl/source/fsstor/fsstorage.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 <com/sun/star/beans/PropertyValue.hpp>
  21 #include <com/sun/star/embed/ElementModes.hpp>
  22 #include <com/sun/star/embed/XTransactedObject.hpp>
  23 #include <com/sun/star/ucb/NameClash.hpp>
  24 #include <com/sun/star/ucb/UniversalContentBroker.hpp>
  25 #include <com/sun/star/ucb/XProgressHandler.hpp>
  26 #include <com/sun/star/ucb/XContentAccess.hpp>
  27 #include <com/sun/star/ucb/SimpleFileAccess.hpp>
  28
  29 #include <com/sun/star/ucb/InteractiveIOException.hpp>
  30 #include <com/sun/star/ucb/IOErrorCode.hpp>
  31 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
  32 #include <com/sun/star/container/XEnumerationAccess.hpp>
  33 #include <com/sun/star/container/XNamed.hpp>
  34 #include <com/sun/star/util/XChangesBatch.hpp>
  35 #include <com/sun/star/util/XCloneable.hpp>
  36 #include <com/sun/star/lang/XUnoTunnel.hpp>
  37 #include <com/sun/star/lang/XComponent.hpp>
  38 #include <com/sun/star/lang/DisposedException.hpp>
  39 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
  40 #include <com/sun/star/io/IOException.hpp>
  41 #include <com/sun/star/io/XTruncate.hpp>
  42 #include <com/sun/star/io/TempFile.hpp>
  43 #include <com/sun/star/sdbc/XResultSet.hpp>
  44 #include <com/sun/star/sdbc/XRow.hpp>
  45
  46
  47 #include <comphelper/processfactory.hxx>
  48 #include <comphelper/storagehelper.hxx>
  49 #include <cppuhelper/queryinterface.hxx>
  50 #include <cppuhelper/typeprovider.hxx>
  51 #include <cppuhelper/exc_hlp.hxx>
  52
  53 #include <tools/urlobj.hxx>
  54 #include <unotools/ucbhelper.hxx>
  55 #include <unotools/ucbstreamhelper.hxx>
  56 #include <unotools/streamwrap.hxx>
  57 #include <ucbhelper/fileidentifierconverter.hxx>
  58 #include <ucbhelper/content.hxx>
  59
  60 #include "fsstorage.hxx"
  61 #include "oinputstreamcontainer.hxx"
  62 #include "ostreamcontainer.hxx"
  63
  64 using namespace ::com::sun::star;
  65
  66
  67 // TODO: move to a standard helper
  68 bool isLocalFile_Impl( const OUString& aURL )
  69 {
  70     OUString aSystemPath;
  71
  72     try
  73     {
  74         aSystemPath = ::ucbhelper::getSystemPathFromFileURL(
  75             ucb::UniversalContentBroker::create(
  76                 comphelper::getProcessComponentContext() ),
  77             aURL );
  78     }
  79     catch ( uno::Exception& )
  80     {
  81     }
  82
  83     return ( !aSystemPath.isEmpty() );
  84 }
  85
  86
  87
  88 struct FSStorage_Impl
  89 {
  90     OUString m_aURL;
  91
  92     ::ucbhelper::Content* m_pContent;
  93     sal_Int32 m_nMode;
  94
  95     ::cppu::OInterfaceContainerHelper* m_pListenersContainer; // list of listeners
  96     ::cppu::OTypeCollection* m_pTypeCollection;
  97
  98     uno::Reference< uno::XComponentContext > m_xContext;
  99
 100
 101     FSStorage_Impl( const ::ucbhelper::Content& aContent, sal_Int32 nMode, uno::Reference< uno::XComponentContext > xContext )
 102     : m_aURL( aContent.getURL() )
 103     , m_pContent( new ::ucbhelper::Content( aContent ) )
 104     , m_nMode( nMode )
 105     , m_pListenersContainer( NULL )
 106     , m_pTypeCollection( NULL )
 107     , m_xContext( xContext )
 108     {
 109         OSL_ENSURE( !m_aURL.isEmpty(), "The URL must not be empty" );
 110     }
 111
 112     ~FSStorage_Impl();
 113 };
 114
 115
 116 FSStorage_Impl::~FSStorage_Impl()
 117 {
 118     if ( m_pListenersContainer )
 119         delete m_pListenersContainer;
 120     if ( m_pTypeCollection )
 121         delete m_pTypeCollection;
 122     if ( m_pContent )
 123         delete m_pContent;
 124 }
 125
 126 FSStorage::FSStorage( const ::ucbhelper::Content& aContent,
 127                     sal_Int32 nMode,
 128                     uno::Reference< uno::XComponentContext > xContext )
 129 : m_pImpl( new FSStorage_Impl( aContent, nMode, xContext ) )
 130 {
 131     // TODO: use properties
 132     if ( !xContext.is() )
 133         throw uno::RuntimeException();
 134
 135     GetContent();
 136 }
 137
 138 FSStorage::~FSStorage()
 139 {
 140     {
 141         ::osl::MutexGuard aGuard( m_aMutex );
 142         m_refCount++; // to call dispose
 143         try {
 144             dispose();
 145         }
 146         catch( uno::RuntimeException& )
 147         {}
 148     }
 149 }
 150
 151 bool FSStorage::MakeFolderNoUI( const OUString& rFolder )
 152 {
 153     INetURLObject aURL( rFolder );
 154     OUString aTitle = aURL.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DECODE_WITH_CHARSET );
 155     aURL.removeSegment();
 156     ::ucbhelper::Content aParent;
 157     ::ucbhelper::Content aResultContent;
 158
 159        if ( ::ucbhelper::Content::create( aURL.GetMainURL( INetURLObject::NO_DECODE ),
 160                                  uno::Reference< ucb::XCommandEnvironment >(),
 161                                  comphelper::getProcessComponentContext(),
 162                                  aParent ) )
 163         return ::utl::UCBContentHelper::MakeFolder( aParent, aTitle, aResultContent, false );
 164
 165     return false;
 166 }
 167
 168 ::ucbhelper::Content* FSStorage::GetContent()
 169 {
 170     ::osl::MutexGuard aGuard( m_aMutex );
 171     if ( !m_pImpl->m_pContent )
 172     {
 173         uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
 174
 175         try
 176         {
 177             m_pImpl->m_pContent = new ::ucbhelper::Content( m_pImpl->m_aURL, xDummyEnv, comphelper::getProcessComponentContext() );
 178         }
 179         catch( uno::Exception& )
 180         {
 181         }
 182     }
 183
 184     return m_pImpl->m_pContent;
 185 }
 186
 187 void FSStorage::CopyStreamToSubStream( const OUString& aSourceURL,
 188                                         const uno::Reference< embed::XStorage >& xDest,
 189                                         const OUString& aNewEntryName )
 190 {
 191     if ( !xDest.is() )
 192         throw uno::RuntimeException();
 193
 194     uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
 195     ::ucbhelper::Content aSourceContent( aSourceURL, xDummyEnv, comphelper::getProcessComponentContext() );
 196     uno::Reference< io::XInputStream > xSourceInput = aSourceContent.openStream();
 197
 198     if ( !xSourceInput.is() )
 199         throw io::IOException(); // TODO: error handling
 200
 201     uno::Reference< io::XStream > xSubStream = xDest->openStreamElement(
 202                                                 aNewEntryName,
 203                                                 embed::ElementModes::READWRITE | embed::ElementModes::TRUNCATE );
 204     if ( !xSubStream.is() )
 205         throw uno::RuntimeException();
 206
 207     uno::Reference< io::XOutputStream > xDestOutput = xSubStream->getOutputStream();
 208     if ( !xDestOutput.is() )
 209         throw uno::RuntimeException();
 210
 211     ::comphelper::OStorageHelper::CopyInputToOutput( xSourceInput, xDestOutput );
 212     xDestOutput->closeOutput();
 213 }
 214
 215 void FSStorage::CopyContentToStorage_Impl( ::ucbhelper::Content* pContent, const uno::Reference< embed::XStorage >& xDest )
 216 {
 217     if ( !pContent )
 218         throw uno::RuntimeException();
 219
 220     // get list of contents of the Content
 221     // create cursor for access to children
 222     uno::Sequence< OUString > aProps( 2 );
 223     OUString* pProps = aProps.getArray();
 224     pProps[0] = "TargetURL";
 225     pProps[1] = "IsFolder";
 226     ::ucbhelper::ResultSetInclude eInclude = ::ucbhelper::INCLUDE_FOLDERS_AND_DOCUMENTS;
 227
 228     try
 229     {
 230         uno::Reference< sdbc::XResultSet > xResultSet = pContent->createCursor( aProps, eInclude );
 231         uno::Reference< ucb::XContentAccess > xContentAccess( xResultSet, uno::UNO_QUERY );
 232         uno::Reference< sdbc::XRow > xRow( xResultSet, uno::UNO_QUERY );
 233         if ( xResultSet.is() )
 234         {
 235             // go through the list: insert files as streams, insert folders as substorages using recursion
 236             while ( xResultSet->next() )
 237             {
 238                 OUString aSourceURL( xRow->getString( 1 ) );
 239                 bool bIsFolder( xRow->getBoolean(2) );
 240
 241                 // TODO/LATER: not sure whether the entry name must be encoded
 242                 OUString aNewEntryName( INetURLObject( aSourceURL ).getName( INetURLObject::LAST_SEGMENT,
 243                                                                                     true,
 244                                                                                     INetURLObject::NO_DECODE ) );
 245                 if ( bIsFolder )
 246                 {
 247                     uno::Reference< embed::XStorage > xSubStorage = xDest->openStorageElement( aNewEntryName,
 248                                                                                                 embed::ElementModes::READWRITE );
 249                     if ( !xSubStorage.is() )
 250                         throw uno::RuntimeException();
 251
 252                     uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
 253                     ::ucbhelper::Content aSourceContent( aSourceURL, xDummyEnv, comphelper::getProcessComponentContext() );
 254                     CopyContentToStorage_Impl( &aSourceContent, xSubStorage );
 255                 }
 256                 else
 257                 {
 258                     CopyStreamToSubStream( aSourceURL, xDest, aNewEntryName );
 259                 }
 260             }
 261         }
 262
 263         uno::Reference< embed::XTransactedObject > xTransact( xDest, uno::UNO_QUERY );
 264         if ( xTransact.is() )
 265             xTransact->commit();
 266     }
 267     catch( ucb::InteractiveIOException& r )
 268     {
 269         if ( r.Code == ucb::IOErrorCode_NOT_EXISTING )
 270             OSL_FAIL( "The folder does not exist!\n" );
 271         else
 272             throw;
 273     }
 274 }
 275
 276 //  XInterface
 277
 278 uno::Any SAL_CALL FSStorage::queryInterface( const uno::Type& rType )
 279         throw( uno::RuntimeException, std::exception )
 280 {
 281     uno::Any aReturn;
 282     aReturn <<= ::cppu::queryInterface
 283                 (   rType
 284                 ,   static_cast<lang::XTypeProvider*> ( this )
 285                 ,   static_cast<embed::XStorage*> ( this )
 286                 ,   static_cast<embed::XHierarchicalStorageAccess*> ( this )
 287                 ,   static_cast<container::XNameAccess*> ( this )
 288                 ,   static_cast<container::XElementAccess*> ( this )
 289                 ,   static_cast<lang::XComponent*> ( this )
 290                 ,   static_cast<beans::XPropertySet*> ( this ) );
 291
 292     if ( aReturn.hasValue() )
 293         return aReturn ;
 294
 295     return OWeakObject::queryInterface( rType );
 296 }
 297
 298 void SAL_CALL FSStorage::acquire() throw()
 299 {
 300     OWeakObject::acquire();
 301 }
 302
 303 void SAL_CALL FSStorage::release() throw()
 304 {
 305     OWeakObject::release();
 306 }
 307
 308 //  XTypeProvider
 309
 310 uno::Sequence< uno::Type > SAL_CALL FSStorage::getTypes()
 311         throw( uno::RuntimeException, std::exception )
 312 {
 313     if ( m_pImpl->m_pTypeCollection == NULL )
 314     {
 315         ::osl::MutexGuard aGuard( m_aMutex );
 316
 317         if ( m_pImpl->m_pTypeCollection == NULL )
 318         {
 319             m_pImpl->m_pTypeCollection = new ::cppu::OTypeCollection
 320                                 (   cppu::UnoType<lang::XTypeProvider>::get()
 321                                 ,   cppu::UnoType<embed::XStorage>::get()
 322                                 ,   cppu::UnoType<embed::XHierarchicalStorageAccess>::get()
 323                                 ,   cppu::UnoType<beans::XPropertySet>::get());
 324         }
 325     }
 326
 327     return m_pImpl->m_pTypeCollection->getTypes() ;
 328 }
 329
 330 uno::Sequence< sal_Int8 > SAL_CALL FSStorage::getImplementationId()
 331         throw( uno::RuntimeException, std::exception )
 332 {
 333     return css::uno::Sequence<sal_Int8>();
 334 }
 335
 336 //  XStorage
 337
 338 void SAL_CALL FSStorage::copyToStorage( const uno::Reference< embed::XStorage >& xDest )
 339         throw ( embed::InvalidStorageException,
 340                 io::IOException,
 341                 lang::IllegalArgumentException,
 342                 embed::StorageWrappedTargetException,
 343                 uno::RuntimeException, std::exception )
 344 {
 345     ::osl::MutexGuard aGuard( m_aMutex );
 346
 347     if ( !m_pImpl )
 348         throw lang::DisposedException();
 349
 350     if ( !xDest.is() || xDest == uno::Reference< uno::XInterface >( static_cast< OWeakObject*> ( this ), uno::UNO_QUERY ) )
 351         throw lang::IllegalArgumentException(); // TODO:
 352
 353     if ( !GetContent() )
 354         throw io::IOException(); // TODO: error handling
 355
 356     try
 357     {
 358         CopyContentToStorage_Impl( GetContent(), xDest );
 359     }
 360     catch( embed::InvalidStorageException& )
 361     {
 362         throw;
 363     }
 364     catch( lang::IllegalArgumentException& )
 365     {
 366         throw;
 367     }
 368     catch( embed::StorageWrappedTargetException& )
 369     {
 370         throw;
 371     }
 372     catch( io::IOException& )
 373     {
 374         throw;
 375     }
 376     catch( uno::RuntimeException& )
 377     {
 378         throw;
 379     }
 380     catch( uno::Exception& )
 381     {
 382           uno::Any aCaught( ::cppu::getCaughtException() );
 383         throw embed::StorageWrappedTargetException("Can't copy raw stream",
 384                                                  uno::Reference< io::XInputStream >(),
 385                                                  aCaught );
 386     }
 387 }
 388
 389 uno::Reference< io::XStream > SAL_CALL FSStorage::openStreamElement(
 390     const OUString& aStreamName, sal_Int32 nOpenMode )
 391         throw ( embed::InvalidStorageException,
 392                 lang::IllegalArgumentException,
 393                 packages::WrongPasswordException,
 394                 io::IOException,
 395                 embed::StorageWrappedTargetException,
 396                 uno::RuntimeException, std::exception )
 397 {
 398     ::osl::MutexGuard aGuard( m_aMutex );
 399
 400     if ( !m_pImpl )
 401         throw lang::DisposedException();
 402
 403     if ( !GetContent() )
 404         throw io::IOException(); // TODO: error handling
 405
 406     // TODO/LATER: may need possibility to create folder if it was removed, since the folder can not be locked
 407     INetURLObject aFileURL( m_pImpl->m_aURL );
 408     aFileURL.Append( aStreamName );
 409
 410     if ( ::utl::UCBContentHelper::IsFolder( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
 411         throw io::IOException();
 412
 413     if ( ( nOpenMode & embed::ElementModes::NOCREATE )
 414       && !::utl::UCBContentHelper::IsDocument( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
 415         throw io::IOException(); // TODO:
 416
 417     uno::Reference< ucb::XCommandEnvironment > xDummyEnv; // TODO: provide InteractionHandler if any
 418     uno::Reference< io::XStream > xResult;
 419     try
 420     {
 421         if ( nOpenMode & embed::ElementModes::WRITE )
 422         {
 423             if ( isLocalFile_Impl( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
 424             {
 425                 uno::Reference<ucb::XSimpleFileAccess3> xSimpleFileAccess(
 426                     ucb::SimpleFileAccess::create( m_pImpl->m_xContext ) );
 427                 xResult = xSimpleFileAccess->openFileReadWrite( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) );
 428             }
 429             else
 430             {
 431                 // TODO: test whether it really works for http and fwp
 432                 SvStream* pStream = ::utl::UcbStreamHelper::CreateStream( aFileURL.GetMainURL( INetURLObject::NO_DECODE ),
 433                                                                           STREAM_STD_WRITE );
 434                 if ( pStream )
 435                 {
 436                     if ( !pStream->GetError() )
 437                         xResult = uno::Reference < io::XStream >( new ::utl::OStreamWrapper( *pStream ) );
 438                     else
 439                         delete pStream;
 440                 }
 441             }
 442
 443             if ( !xResult.is() )
 444                 throw io::IOException();
 445
 446             if ( ( nOpenMode & embed::ElementModes::TRUNCATE ) )
 447             {
 448                 uno::Reference< io::XTruncate > xTrunc( xResult->getOutputStream(), uno::UNO_QUERY_THROW );
 449                 xTrunc->truncate();
 450             }
 451         }
 452         else
 453         {
 454             if ( ( nOpenMode & embed::ElementModes::TRUNCATE )
 455               || !::utl::UCBContentHelper::IsDocument( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
 456                 throw io::IOException(); // TODO: access denied
 457
 458             ::ucbhelper::Content aResultContent( aFileURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv, comphelper::getProcessComponentContext() );
 459             uno::Reference< io::XInputStream > xInStream = aResultContent.openStream();
 460             xResult = static_cast< io::XStream* >( new OFSInputStreamContainer( xInStream ) );
 461         }
 462     }
 463     catch( embed::InvalidStorageException& )
 464     {
 465         throw;
 466     }
 467     catch( lang::IllegalArgumentException& )
 468     {
 469         throw;
 470     }
 471     catch( packages::WrongPasswordException& )
 472     {
 473         throw;
 474     }
 475     catch( embed::StorageWrappedTargetException& )
 476     {
 477         throw;
 478     }
 479     catch( io::IOException& )
 480     {
 481         throw;
 482     }
 483     catch( uno::RuntimeException& )
 484     {
 485         throw;
 486     }
 487     catch( uno::Exception& )
 488     {
 489           uno::Any aCaught( ::cppu::getCaughtException() );
 490         throw embed::StorageWrappedTargetException("Can't copy raw stream",
 491                                                  uno::Reference< io::XInputStream >(),
 492                                                  aCaught );
 493     }
 494
 495     return xResult;
 496 }
 497
 498 uno::Reference< io::XStream > SAL_CALL FSStorage::openEncryptedStreamElement(
 499     const OUString&, sal_Int32, const OUString& )
 500         throw ( embed::InvalidStorageException,
 501                 lang::IllegalArgumentException,
 502                 packages::NoEncryptionException,
 503                 packages::WrongPasswordException,
 504                 io::IOException,
 505                 embed::StorageWrappedTargetException,
 506                 uno::RuntimeException, std::exception )
 507 {
 508     throw packages::NoEncryptionException();
 509 }
 510
 511 uno::Reference< embed::XStorage > SAL_CALL FSStorage::openStorageElement(
 512             const OUString& aStorName, sal_Int32 nStorageMode )
 513         throw ( embed::InvalidStorageException,
 514                 lang::IllegalArgumentException,
 515                 io::IOException,
 516                 embed::StorageWrappedTargetException,
 517                 uno::RuntimeException, std::exception )
 518 {
 519     ::osl::MutexGuard aGuard( m_aMutex );
 520
 521     if ( !m_pImpl )
 522         throw lang::DisposedException();
 523
 524     if ( !GetContent() )
 525         throw io::IOException(); // TODO: error handling
 526
 527     if ( ( nStorageMode & embed::ElementModes::WRITE )
 528       && !( m_pImpl->m_nMode & embed::ElementModes::WRITE ) )
 529           throw io::IOException(); // TODO: error handling
 530
 531     // TODO/LATER: may need possibility to create folder if it was removed, since the folder can not be locked
 532     INetURLObject aFolderURL( m_pImpl->m_aURL );
 533     aFolderURL.Append( aStorName );
 534
 535     bool bFolderExists = ::utl::UCBContentHelper::IsFolder( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ) );
 536     if ( !bFolderExists && ::utl::UCBContentHelper::IsDocument( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
 537         throw io::IOException(); // TODO:
 538
 539     if ( ( nStorageMode & embed::ElementModes::NOCREATE ) && !bFolderExists )
 540         throw io::IOException(); // TODO:
 541
 542     uno::Reference< ucb::XCommandEnvironment > xDummyEnv; // TODO: provide InteractionHandler if any
 543     uno::Reference< embed::XStorage > xResult;
 544     try
 545     {
 546         if ( nStorageMode & embed::ElementModes::WRITE )
 547         {
 548             if ( ( nStorageMode & embed::ElementModes::TRUNCATE ) && bFolderExists )
 549             {
 550                 ::utl::UCBContentHelper::Kill( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ) );
 551                 bFolderExists =
 552                     MakeFolderNoUI( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ) ); // TODO: not atomic :(
 553             }
 554             else if ( !bFolderExists )
 555             {
 556                 bFolderExists =
 557                     MakeFolderNoUI( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ) ); // TODO: not atomic :(
 558             }
 559         }
 560         else if ( ( nStorageMode & embed::ElementModes::TRUNCATE ) )
 561             throw io::IOException(); // TODO: access denied
 562
 563         if ( !bFolderExists )
 564             throw io::IOException(); // there is no such folder
 565
 566         ::ucbhelper::Content aResultContent( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv, comphelper::getProcessComponentContext() );
 567         xResult = uno::Reference< embed::XStorage >(
 568                             static_cast< OWeakObject* >( new FSStorage( aResultContent,
 569                                                                         nStorageMode,
 570                                                                         m_pImpl->m_xContext ) ),
 571                             uno::UNO_QUERY );
 572     }
 573     catch( embed::InvalidStorageException& )
 574     {
 575         throw;
 576     }
 577     catch( lang::IllegalArgumentException& )
 578     {
 579         throw;
 580     }
 581     catch( embed::StorageWrappedTargetException& )
 582     {
 583         throw;
 584     }
 585     catch( io::IOException& )
 586     {
 587         throw;
 588     }
 589     catch( uno::RuntimeException& )
 590     {
 591         throw;
 592     }
 593     catch( uno::Exception& )
 594     {
 595           uno::Any aCaught( ::cppu::getCaughtException() );
 596         throw embed::StorageWrappedTargetException("Can't copy raw stream",
 597                                                  uno::Reference< io::XInputStream >(),
 598                                                  aCaught );
 599     }
 600
 601     return xResult;
 602 }
 603
 604 uno::Reference< io::XStream > SAL_CALL FSStorage::cloneStreamElement( const OUString& aStreamName )
 605         throw ( embed::InvalidStorageException,
 606                 lang::IllegalArgumentException,
 607                 packages::WrongPasswordException,
 608                 io::IOException,
 609                 embed::StorageWrappedTargetException,
 610                 uno::RuntimeException, std::exception )
 611 {
 612     ::osl::MutexGuard aGuard( m_aMutex );
 613
 614     if ( !m_pImpl )
 615         throw lang::DisposedException();
 616
 617     if ( !GetContent() )
 618         throw io::IOException(); // TODO: error handling
 619
 620     // TODO/LATER: may need possibility to create folder if it was removed, since the folder can not be locked
 621     INetURLObject aFileURL( m_pImpl->m_aURL );
 622     aFileURL.Append( aStreamName );
 623
 624     uno::Reference < io::XStream > xTempResult;
 625     try
 626     {
 627         uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
 628         ::ucbhelper::Content aResultContent( aFileURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv, comphelper::getProcessComponentContext() );
 629         uno::Reference< io::XInputStream > xInStream = aResultContent.openStream();
 630
 631         xTempResult = io::TempFile::create(m_pImpl->m_xContext);
 632         uno::Reference < io::XOutputStream > xTempOut = xTempResult->getOutputStream();
 633         uno::Reference < io::XInputStream > xTempIn = xTempResult->getInputStream();
 634
 635         if ( !xTempOut.is() || !xTempIn.is() )
 636             throw io::IOException();
 637
 638         ::comphelper::OStorageHelper::CopyInputToOutput( xInStream, xTempOut );
 639         xTempOut->closeOutput();
 640     }
 641     catch( embed::InvalidStorageException& )
 642     {
 643         throw;
 644     }
 645     catch( lang::IllegalArgumentException& )
 646     {
 647         throw;
 648     }
 649     catch( packages::WrongPasswordException& )
 650     {
 651         throw;
 652     }
 653     catch( io::IOException& )
 654     {
 655         throw;
 656     }
 657     catch( embed::StorageWrappedTargetException& )
 658     {
 659         throw;
 660     }
 661     catch( uno::RuntimeException& )
 662     {
 663         throw;
 664     }
 665     catch( uno::Exception& )
 666     {
 667           uno::Any aCaught( ::cppu::getCaughtException() );
 668         throw embed::StorageWrappedTargetException("Can't copy raw stream",
 669                                                  uno::Reference< io::XInputStream >(),
 670                                                  aCaught );
 671     }
 672
 673     return xTempResult;
 674 }
 675
 676 uno::Reference< io::XStream > SAL_CALL FSStorage::cloneEncryptedStreamElement(
 677     const OUString&,
 678     const OUString& )
 679         throw ( embed::InvalidStorageException,
 680                 lang::IllegalArgumentException,
 681                 packages::NoEncryptionException,
 682                 packages::WrongPasswordException,
 683                 io::IOException,
 684                 embed::StorageWrappedTargetException,
 685                 uno::RuntimeException, std::exception )
 686 {
 687     throw packages::NoEncryptionException();
 688 }
 689
 690 void SAL_CALL FSStorage::copyLastCommitTo(
 691             const uno::Reference< embed::XStorage >& xTargetStorage )
 692         throw ( embed::InvalidStorageException,
 693                 lang::IllegalArgumentException,
 694                 io::IOException,
 695                 embed::StorageWrappedTargetException,
 696                 uno::RuntimeException, std::exception )
 697 {
 698     copyToStorage( xTargetStorage );
 699 }
 700
 701 void SAL_CALL FSStorage::copyStorageElementLastCommitTo(
 702             const OUString& aStorName,
 703             const uno::Reference< embed::XStorage >& xTargetStorage )
 704         throw ( embed::InvalidStorageException,
 705                 lang::IllegalArgumentException,
 706                 io::IOException,
 707                 embed::StorageWrappedTargetException,
 708                 uno::RuntimeException, std::exception )
 709 {
 710     ::osl::MutexGuard aGuard( m_aMutex );
 711
 712     if ( !m_pImpl )
 713         throw lang::DisposedException();
 714
 715     uno::Reference< embed::XStorage > xSourceStor( openStorageElement( aStorName, embed::ElementModes::READ ),
 716                                                     uno::UNO_QUERY_THROW );
 717     xSourceStor->copyToStorage( xTargetStorage );
 718 }
 719
 720 sal_Bool SAL_CALL FSStorage::isStreamElement( const OUString& aElementName )
 721         throw ( embed::InvalidStorageException,
 722                 lang::IllegalArgumentException,
 723                 container::NoSuchElementException,
 724                 uno::RuntimeException, std::exception )
 725 {
 726     ::osl::MutexGuard aGuard( m_aMutex );
 727
 728     if ( !m_pImpl )
 729         throw lang::DisposedException();
 730
 731     if ( !GetContent() )
 732         throw embed::InvalidStorageException(); // TODO: error handling
 733
 734     INetURLObject aURL( m_pImpl->m_aURL );
 735     aURL.Append( aElementName );
 736
 737     return !::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) );
 738 }
 739
 740 sal_Bool SAL_CALL FSStorage::isStorageElement( const OUString& aElementName )
 741         throw ( embed::InvalidStorageException,
 742                 lang::IllegalArgumentException,
 743                 container::NoSuchElementException,
 744                 uno::RuntimeException, std::exception )
 745 {
 746     ::osl::MutexGuard aGuard( m_aMutex );
 747
 748     if ( !m_pImpl )
 749         throw lang::DisposedException();
 750
 751     if ( !GetContent() )
 752         throw embed::InvalidStorageException(); // TODO: error handling
 753
 754     INetURLObject aURL( m_pImpl->m_aURL );
 755     aURL.Append( aElementName );
 756
 757     return ::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) );
 758 }
 759
 760 void SAL_CALL FSStorage::removeElement( const OUString& aElementName )
 761         throw ( embed::InvalidStorageException,
 762                 lang::IllegalArgumentException,
 763                 container::NoSuchElementException,
 764                 io::IOException,
 765                 embed::StorageWrappedTargetException,
 766                 uno::RuntimeException, std::exception )
 767 {
 768     ::osl::MutexGuard aGuard( m_aMutex );
 769
 770     if ( !m_pImpl )
 771         throw lang::DisposedException();
 772
 773     if ( !GetContent() )
 774         throw io::IOException(); // TODO: error handling
 775
 776     INetURLObject aURL( m_pImpl->m_aURL );
 777     aURL.Append( aElementName );
 778
 779     if ( !::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) )
 780       && !::utl::UCBContentHelper::IsDocument( aURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
 781         throw container::NoSuchElementException(); // TODO:
 782
 783     ::utl::UCBContentHelper::Kill( aURL.GetMainURL( INetURLObject::NO_DECODE ) );
 784 }
 785
 786 void SAL_CALL FSStorage::renameElement( const OUString& aElementName, const OUString& aNewName )
 787         throw ( embed::InvalidStorageException,
 788                 lang::IllegalArgumentException,
 789                 container::NoSuchElementException,
 790                 container::ElementExistException,
 791                 io::IOException,
 792                 embed::StorageWrappedTargetException,
 793                 uno::RuntimeException, std::exception )
 794 {
 795     ::osl::MutexGuard aGuard( m_aMutex );
 796
 797     if ( !m_pImpl )
 798         throw lang::DisposedException();
 799
 800     if ( !GetContent() )
 801         throw io::IOException(); // TODO: error handling
 802
 803     INetURLObject aOldURL( m_pImpl->m_aURL );
 804     aOldURL.Append( aElementName );
 805
 806     INetURLObject aNewURL( m_pImpl->m_aURL );
 807     aNewURL.Append( aNewName );
 808
 809     if ( !::utl::UCBContentHelper::IsFolder( aOldURL.GetMainURL( INetURLObject::NO_DECODE ) )
 810       && !::utl::UCBContentHelper::IsDocument( aOldURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
 811         throw container::NoSuchElementException(); // TODO:
 812
 813     if ( ::utl::UCBContentHelper::IsFolder( aNewURL.GetMainURL( INetURLObject::NO_DECODE ) )
 814       || ::utl::UCBContentHelper::IsDocument( aNewURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
 815           throw container::ElementExistException(); // TODO:
 816
 817     try
 818     {
 819         uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
 820         ::ucbhelper::Content aSourceContent( aOldURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv, comphelper::getProcessComponentContext() );
 821
 822         if ( !GetContent()->transferContent( aSourceContent,
 823                                             ::ucbhelper::InsertOperation_MOVE,
 824                                             aNewName,
 825                                             ucb::NameClash::ERROR ) )
 826             throw io::IOException(); // TODO: error handling
 827     }
 828     catch( embed::InvalidStorageException& )
 829     {
 830         throw;
 831     }
 832     catch( lang::IllegalArgumentException& )
 833     {
 834         throw;
 835     }
 836     catch( container::NoSuchElementException& )
 837     {
 838         throw;
 839     }
 840     catch( container::ElementExistException& )
 841     {
 842         throw;
 843     }
 844     catch( io::IOException& )
 845     {
 846         throw;
 847     }
 848     catch( embed::StorageWrappedTargetException& )
 849     {
 850         throw;
 851     }
 852     catch( uno::RuntimeException& )
 853     {
 854         throw;
 855     }
 856     catch( uno::Exception& )
 857     {
 858           uno::Any aCaught( ::cppu::getCaughtException() );
 859         throw embed::StorageWrappedTargetException("Can't copy raw stream",
 860                                                  uno::Reference< io::XInputStream >(),
 861                                                  aCaught );
 862     }
 863 }
 864
 865 void SAL_CALL FSStorage::copyElementTo( const OUString& aElementName,
 866                                         const uno::Reference< embed::XStorage >& xDest,
 867                                         const OUString& aNewName )
 868         throw ( embed::InvalidStorageException,
 869                 lang::IllegalArgumentException,
 870                 container::NoSuchElementException,
 871                 container::ElementExistException,
 872                 io::IOException,
 873                 embed::StorageWrappedTargetException,
 874                 uno::RuntimeException, std::exception )
 875 {
 876     ::osl::MutexGuard aGuard( m_aMutex );
 877
 878     if ( !m_pImpl )
 879         throw lang::DisposedException();
 880
 881     if ( !xDest.is() )
 882         throw uno::RuntimeException();
 883
 884     if ( !GetContent() )
 885         throw io::IOException(); // TODO: error handling
 886
 887     INetURLObject aOwnURL( m_pImpl->m_aURL );
 888     aOwnURL.Append( aElementName );
 889
 890     if ( xDest->hasByName( aNewName ) )
 891           throw container::ElementExistException(); // TODO:
 892
 893     try
 894     {
 895         uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
 896         if ( ::utl::UCBContentHelper::IsFolder( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
 897         {
 898             ::ucbhelper::Content aSourceContent( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv, comphelper::getProcessComponentContext() );
 899             uno::Reference< embed::XStorage > xDestSubStor(
 900                                     xDest->openStorageElement( aNewName, embed::ElementModes::READWRITE ),
 901                                     uno::UNO_QUERY_THROW );
 902
 903             CopyContentToStorage_Impl( &aSourceContent, xDestSubStor );
 904         }
 905         else if ( ::utl::UCBContentHelper::IsDocument( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
 906         {
 907             CopyStreamToSubStream( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ), xDest, aNewName );
 908         }
 909         else
 910             throw container::NoSuchElementException(); // TODO:
 911     }
 912     catch( embed::InvalidStorageException& )
 913     {
 914         throw;
 915     }
 916     catch( lang::IllegalArgumentException& )
 917     {
 918         throw;
 919     }
 920     catch( container::NoSuchElementException& )
 921     {
 922         throw;
 923     }
 924     catch( container::ElementExistException& )
 925     {
 926         throw;
 927     }
 928     catch( embed::StorageWrappedTargetException& )
 929     {
 930         throw;
 931     }
 932     catch( io::IOException& )
 933     {
 934         throw;
 935     }
 936     catch( uno::RuntimeException& )
 937     {
 938         throw;
 939     }
 940     catch( uno::Exception& )
 941     {
 942           uno::Any aCaught( ::cppu::getCaughtException() );
 943         throw embed::StorageWrappedTargetException("Can't copy raw stream",
 944                                                  uno::Reference< io::XInputStream >(),
 945                                                  aCaught );
 946     }
 947 }
 948
 949 void SAL_CALL FSStorage::moveElementTo( const OUString& aElementName,
 950                                         const uno::Reference< embed::XStorage >& xDest,
 951                                         const OUString& aNewName )
 952         throw ( embed::InvalidStorageException,
 953                 lang::IllegalArgumentException,
 954                 container::NoSuchElementException,
 955                 container::ElementExistException,
 956                 io::IOException,
 957                 embed::StorageWrappedTargetException,
 958                 uno::RuntimeException, std::exception )
 959 {
 960     ::osl::MutexGuard aGuard( m_aMutex );
 961     copyElementTo( aElementName, xDest, aNewName );
 962
 963     INetURLObject aOwnURL( m_pImpl->m_aURL );
 964     aOwnURL.Append( aElementName );
 965     if ( !::utl::UCBContentHelper::Kill( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
 966         throw io::IOException(); // TODO: error handling
 967 }
 968
 969 //  XNameAccess
 970
 971 uno::Any SAL_CALL FSStorage::getByName( const OUString& aName )
 972         throw ( container::NoSuchElementException,
 973                 lang::WrappedTargetException,
 974                 uno::RuntimeException, std::exception )
 975 {
 976     ::osl::MutexGuard aGuard( m_aMutex );
 977
 978     if ( !m_pImpl )
 979         throw lang::DisposedException();
 980
 981     if ( aName.isEmpty() )
 982         throw lang::IllegalArgumentException();
 983
 984     uno::Any aResult;
 985     try
 986     {
 987         if ( !GetContent() )
 988             throw io::IOException(); // TODO: error handling
 989
 990         INetURLObject aURL( m_pImpl->m_aURL );
 991         aURL.Append( aName );
 992
 993
 994         if ( ::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
 995         {
 996             aResult <<= openStorageElement( aName, embed::ElementModes::READ );
 997         }
 998         else if ( ::utl::UCBContentHelper::IsDocument( aURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
 999         {
1000             aResult <<= openStreamElement( aName, embed::ElementModes::READ );
1001         }
1002         else
1003             throw container::NoSuchElementException(); // TODO:
1004     }
1005     catch (const container::NoSuchElementException&)
1006     {
1007         throw;
1008     }
1009     catch (const lang::WrappedTargetException&)
1010     {
1011         throw;
1012     }
1013     catch (const uno::RuntimeException&)
1014     {
1015         throw;
1016     }
1017     catch (const uno::Exception&)
1018     {
1019         uno::Any aCaught( ::cppu::getCaughtException() );
1020         throw lang::WrappedTargetException( "Can not open element!",
1021                                             static_cast< OWeakObject* >( this ),
1022                                             aCaught );
1023     }
1024
1025     return aResult;
1026 }
1027
1028
1029 uno::Sequence< OUString > SAL_CALL FSStorage::getElementNames()
1030         throw ( uno::RuntimeException, std::exception )
1031 {
1032     ::osl::MutexGuard aGuard( m_aMutex );
1033
1034     if ( !m_pImpl )
1035         throw lang::DisposedException();
1036
1037     uno::Sequence< OUString > aResult;
1038
1039     try
1040     {
1041         if ( !GetContent() )
1042             throw io::IOException(); // TODO: error handling
1043
1044         uno::Sequence< OUString > aProps( 1 );
1045         aProps[0] = "Title";
1046         ::ucbhelper::ResultSetInclude eInclude = ::ucbhelper::INCLUDE_FOLDERS_AND_DOCUMENTS;
1047
1048         sal_Int32 nSize = 0;
1049         uno::Reference< sdbc::XResultSet > xResultSet = GetContent()->createCursor( aProps, eInclude );
1050         uno::Reference< ucb::XContentAccess > xContentAccess( xResultSet, uno::UNO_QUERY );
1051         uno::Reference< sdbc::XRow > xRow( xResultSet, uno::UNO_QUERY );
1052         if ( xResultSet.is() )
1053         {
1054             // go through the list
1055             while ( xResultSet->next() )
1056             {
1057                 OUString aName( xRow->getString( 1 ) );
1058                 aResult.realloc( ++nSize );
1059                 aResult[nSize-1] = aName;
1060             }
1061         }
1062     }
1063     catch( const ucb::InteractiveIOException& r )
1064     {
1065         if ( r.Code == ucb::IOErrorCode_NOT_EXISTING )
1066             OSL_FAIL( "The folder does not exist!\n" );
1067         else
1068         {
1069             uno::Any aCaught( ::cppu::getCaughtException() );
1070             throw lang::WrappedTargetRuntimeException( "Can not open storage!",
1071                                             static_cast< OWeakObject* >( this ),
1072                                             aCaught );
1073         }
1074     }
1075     catch (const uno::RuntimeException&)
1076     {
1077         throw;
1078     }
1079     catch (const uno::Exception&)
1080     {
1081         uno::Any aCaught( ::cppu::getCaughtException() );
1082         throw lang::WrappedTargetRuntimeException( "Can not open storage!",
1083                                             static_cast< OWeakObject* >( this ),
1084                                             aCaught );
1085     }
1086
1087     return aResult;
1088 }
1089
1090 sal_Bool SAL_CALL FSStorage::hasByName( const OUString& aName )
1091         throw ( uno::RuntimeException, std::exception )
1092 {
1093     ::osl::MutexGuard aGuard( m_aMutex );
1094
1095     if ( !m_pImpl )
1096         throw lang::DisposedException();
1097
1098     try
1099     {
1100         if ( !GetContent() )
1101             throw io::IOException(); // TODO: error handling
1102
1103         if ( aName.isEmpty() )
1104             throw lang::IllegalArgumentException();
1105     }
1106     catch( uno::RuntimeException& )
1107     {
1108         throw;
1109     }
1110     catch ( uno::Exception& )
1111     {
1112         uno::Any aCaught( ::cppu::getCaughtException() );
1113         throw lang::WrappedTargetRuntimeException( "Can not open storage!",
1114                                             static_cast< OWeakObject* >( this ),
1115                                             aCaught );
1116     }
1117
1118     INetURLObject aURL( m_pImpl->m_aURL );
1119     aURL.Append( aName );
1120
1121     return ( ::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) )
1122       || ::utl::UCBContentHelper::IsDocument( aURL.GetMainURL( INetURLObject::NO_DECODE ) ) );
1123 }
1124
1125 uno::Type SAL_CALL FSStorage::getElementType()
1126         throw ( uno::RuntimeException, std::exception )
1127 {
1128     ::osl::MutexGuard aGuard( m_aMutex );
1129
1130     if ( !m_pImpl )
1131         throw lang::DisposedException();
1132
1133     // it is a multitype container
1134     return uno::Type();
1135 }
1136
1137 sal_Bool SAL_CALL FSStorage::hasElements()
1138         throw ( uno::RuntimeException, std::exception )
1139 {
1140     ::osl::MutexGuard aGuard( m_aMutex );
1141
1142     if ( !m_pImpl )
1143         throw lang::DisposedException();
1144
1145     try
1146     {
1147         if ( !GetContent() )
1148             throw io::IOException(); // TODO: error handling
1149
1150         uno::Sequence< OUString > aProps( 1 );
1151         aProps[0] = "TargetURL";
1152         ::ucbhelper::ResultSetInclude eInclude = ::ucbhelper::INCLUDE_FOLDERS_AND_DOCUMENTS;
1153
1154         uno::Reference< sdbc::XResultSet > xResultSet = GetContent()->createCursor( aProps, eInclude );
1155         return ( xResultSet.is() && xResultSet->next() );
1156     }
1157     catch (const uno::RuntimeException&)
1158     {
1159         throw;
1160     }
1161     catch (const uno::Exception&)
1162     {
1163         throw uno::RuntimeException();
1164     }
1165 }
1166
1167 //  XDisposable
1168 void SAL_CALL FSStorage::dispose()
1169         throw ( uno::RuntimeException, std::exception )
1170 {
1171     ::osl::MutexGuard aGuard( m_aMutex );
1172
1173     if ( !m_pImpl )
1174         throw lang::DisposedException();
1175
1176     if ( m_pImpl->m_pListenersContainer )
1177     {
1178         lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >(this) );
1179         m_pImpl->m_pListenersContainer->disposeAndClear( aSource );
1180     }
1181
1182     delete m_pImpl;
1183     m_pImpl = NULL;
1184 }
1185
1186 void SAL_CALL FSStorage::addEventListener(
1187             const uno::Reference< lang::XEventListener >& xListener )
1188         throw ( uno::RuntimeException, std::exception )
1189 {
1190     ::osl::MutexGuard aGuard( m_aMutex );
1191
1192     if ( !m_pImpl )
1193         throw lang::DisposedException();
1194
1195     if ( !m_pImpl->m_pListenersContainer )
1196         m_pImpl->m_pListenersContainer = new ::cppu::OInterfaceContainerHelper( m_aMutex );
1197
1198     m_pImpl->m_pListenersContainer->addInterface( xListener );
1199 }
1200
1201 void SAL_CALL FSStorage::removeEventListener(
1202             const uno::Reference< lang::XEventListener >& xListener )
1203         throw ( uno::RuntimeException, std::exception )
1204 {
1205     ::osl::MutexGuard aGuard( m_aMutex );
1206
1207     if ( !m_pImpl )
1208         throw lang::DisposedException();
1209
1210     if ( m_pImpl->m_pListenersContainer )
1211         m_pImpl->m_pListenersContainer->removeInterface( xListener );
1212 }
1213
1214 //  XPropertySet
1215
1216 uno::Reference< beans::XPropertySetInfo > SAL_CALL FSStorage::getPropertySetInfo()
1217         throw ( uno::RuntimeException, std::exception )
1218 {
1219     ::osl::MutexGuard aGuard( m_aMutex );
1220
1221     if ( !m_pImpl )
1222         throw lang::DisposedException();
1223
1224     //TODO:
1225     return uno::Reference< beans::XPropertySetInfo >();
1226 }
1227
1228
1229 void SAL_CALL FSStorage::setPropertyValue( const OUString& aPropertyName, const uno::Any& )
1230         throw ( beans::UnknownPropertyException,
1231                 beans::PropertyVetoException,
1232                 lang::IllegalArgumentException,
1233                 lang::WrappedTargetException,
1234                 uno::RuntimeException, std::exception )
1235 {
1236     ::osl::MutexGuard aGuard( m_aMutex );
1237
1238     if ( !m_pImpl )
1239         throw lang::DisposedException();
1240
1241     if ( aPropertyName == "URL" || aPropertyName == "OpenMode" )
1242         throw beans::PropertyVetoException(); // TODO
1243     else
1244         throw beans::UnknownPropertyException(); // TODO
1245 }
1246
1247
1248 uno::Any SAL_CALL FSStorage::getPropertyValue( const OUString& aPropertyName )
1249         throw ( beans::UnknownPropertyException,
1250                 lang::WrappedTargetException,
1251                 uno::RuntimeException, std::exception )
1252 {
1253     ::osl::MutexGuard aGuard( m_aMutex );
1254
1255     if ( !m_pImpl )
1256         throw lang::DisposedException();
1257
1258     if ( aPropertyName == "URL" )
1259         return uno::makeAny( m_pImpl->m_aURL );
1260     else if ( aPropertyName == "OpenMode" )
1261         return uno::makeAny( m_pImpl->m_nMode );
1262
1263     throw beans::UnknownPropertyException(); // TODO
1264 }
1265
1266
1267 void SAL_CALL FSStorage::addPropertyChangeListener(
1268             const OUString& /*aPropertyName*/,
1269             const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/ )
1270         throw ( beans::UnknownPropertyException,
1271                 lang::WrappedTargetException,
1272                 uno::RuntimeException, std::exception )
1273 {
1274     ::osl::MutexGuard aGuard( m_aMutex );
1275
1276     if ( !m_pImpl )
1277         throw lang::DisposedException();
1278
1279     //TODO:
1280 }
1281
1282
1283 void SAL_CALL FSStorage::removePropertyChangeListener(
1284             const OUString& /*aPropertyName*/,
1285             const uno::Reference< beans::XPropertyChangeListener >& /*aListener*/ )
1286         throw ( beans::UnknownPropertyException,
1287                 lang::WrappedTargetException,
1288                 uno::RuntimeException, std::exception )
1289 {
1290     ::osl::MutexGuard aGuard( m_aMutex );
1291
1292     if ( !m_pImpl )
1293         throw lang::DisposedException();
1294
1295     //TODO:
1296 }
1297
1298
1299 void SAL_CALL FSStorage::addVetoableChangeListener(
1300             const OUString& /*PropertyName*/,
1301             const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
1302         throw ( beans::UnknownPropertyException,
1303                 lang::WrappedTargetException,
1304                 uno::RuntimeException, std::exception )
1305 {
1306     ::osl::MutexGuard aGuard( m_aMutex );
1307
1308     if ( !m_pImpl )
1309         throw lang::DisposedException();
1310
1311     //TODO:
1312 }
1313
1314
1315 void SAL_CALL FSStorage::removeVetoableChangeListener(
1316             const OUString& /*PropertyName*/,
1317             const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
1318         throw ( beans::UnknownPropertyException,
1319                 lang::WrappedTargetException,
1320                 uno::RuntimeException, std::exception )
1321 {
1322     ::osl::MutexGuard aGuard( m_aMutex );
1323
1324     if ( !m_pImpl )
1325         throw lang::DisposedException();
1326
1327     //TODO:
1328 }
1329
1330 //  XHierarchicalStorageAccess
1331 uno::Reference< embed::XExtendedStorageStream > SAL_CALL FSStorage::openStreamElementByHierarchicalName( const OUString& sStreamPath, ::sal_Int32 nOpenMode )
1332         throw ( embed::InvalidStorageException,
1333                 lang::IllegalArgumentException,
1334                 packages::WrongPasswordException,
1335                 io::IOException,
1336                 embed::StorageWrappedTargetException,
1337                 uno::RuntimeException, std::exception )
1338 {
1339     ::osl::MutexGuard aGuard( m_aMutex );
1340
1341     if ( !m_pImpl )
1342         throw lang::DisposedException();
1343
1344     if ( sStreamPath.toChar() == '/' )
1345         throw lang::IllegalArgumentException();
1346
1347     if ( !GetContent() )
1348         throw io::IOException(); // TODO: error handling
1349
1350     INetURLObject aBaseURL( m_pImpl->m_aURL );
1351     if ( !aBaseURL.setFinalSlash() )
1352         throw uno::RuntimeException();
1353
1354     OUString aFileURL = INetURLObject::GetAbsURL(
1355                 aBaseURL.GetMainURL( INetURLObject::NO_DECODE ),
1356                 sStreamPath );
1357
1358     if ( ::utl::UCBContentHelper::IsFolder( aFileURL ) )
1359         throw io::IOException();
1360
1361     if ( ( nOpenMode & embed::ElementModes::NOCREATE )
1362       && !::utl::UCBContentHelper::IsDocument( aFileURL ) )
1363         throw io::IOException(); // TODO:
1364
1365     uno::Reference< ucb::XCommandEnvironment > xDummyEnv; // TODO: provide InteractionHandler if any
1366     uno::Reference< io::XStream > xResult;
1367     try
1368     {
1369         if ( nOpenMode & embed::ElementModes::WRITE )
1370         {
1371             if ( isLocalFile_Impl( aFileURL ) )
1372             {
1373                 uno::Reference<ucb::XSimpleFileAccess3> xSimpleFileAccess(
1374                     ucb::SimpleFileAccess::create( m_pImpl->m_xContext ) );
1375                 uno::Reference< io::XStream > xStream =
1376                     xSimpleFileAccess->openFileReadWrite( aFileURL );
1377
1378                 xResult = static_cast< io::XStream* >( new OFSStreamContainer( xStream ) );
1379             }
1380             else
1381             {
1382                 // TODO: test whether it really works for http and fwp
1383                 SvStream* pStream = ::utl::UcbStreamHelper::CreateStream( aFileURL,
1384                                                                           STREAM_STD_WRITE );
1385                 if ( pStream )
1386                 {
1387                     if ( !pStream->GetError() )
1388                     {
1389                         uno::Reference< io::XStream > xStream =
1390                             uno::Reference < io::XStream >( new ::utl::OStreamWrapper( *pStream ) );
1391                         xResult = static_cast< io::XStream* >( new OFSStreamContainer( xStream ) );
1392                     }
1393                     else
1394                         delete pStream;
1395                 }
1396             }
1397
1398             if ( !xResult.is() )
1399                 throw io::IOException();
1400
1401             if ( ( nOpenMode & embed::ElementModes::TRUNCATE ) )
1402             {
1403                 uno::Reference< io::XTruncate > xTrunc( xResult->getOutputStream(), uno::UNO_QUERY_THROW );
1404                 xTrunc->truncate();
1405             }
1406         }
1407         else
1408         {
1409             if ( ( nOpenMode & embed::ElementModes::TRUNCATE )
1410               || !::utl::UCBContentHelper::IsDocument( aFileURL ) )
1411                 throw io::IOException(); // TODO: access denied
1412
1413             ::ucbhelper::Content aResultContent( aFileURL, xDummyEnv, comphelper::getProcessComponentContext() );
1414             uno::Reference< io::XInputStream > xInStream = aResultContent.openStream();
1415             xResult = static_cast< io::XStream* >( new OFSInputStreamContainer( xInStream ) );
1416         }
1417     }
1418     catch( embed::InvalidStorageException& )
1419     {
1420         throw;
1421     }
1422     catch( lang::IllegalArgumentException& )
1423     {
1424         throw;
1425     }
1426     catch( packages::WrongPasswordException& )
1427     {
1428         throw;
1429     }
1430     catch( embed::StorageWrappedTargetException& )
1431     {
1432         throw;
1433     }
1434     catch( io::IOException& )
1435     {
1436         throw;
1437     }
1438     catch( uno::RuntimeException& )
1439     {
1440         throw;
1441     }
1442     catch( uno::Exception& )
1443     {
1444           uno::Any aCaught( ::cppu::getCaughtException() );
1445         throw embed::StorageWrappedTargetException("Can't copy raw stream",
1446                                                  uno::Reference< io::XInputStream >(),
1447                                                  aCaught );
1448     }
1449
1450     return uno::Reference< embed::XExtendedStorageStream >( xResult, uno::UNO_QUERY_THROW );
1451 }
1452
1453 uno::Reference< embed::XExtendedStorageStream > SAL_CALL FSStorage::openEncryptedStreamElementByHierarchicalName( const OUString& /*sStreamName*/, ::sal_Int32 /*nOpenMode*/, const OUString& /*sPassword*/ )
1454         throw ( embed::InvalidStorageException,
1455                 lang::IllegalArgumentException,
1456                 packages::NoEncryptionException,
1457                 packages::WrongPasswordException,
1458                 io::IOException,
1459                 embed::StorageWrappedTargetException,
1460                 uno::RuntimeException, std::exception )
1461 {
1462     throw packages::NoEncryptionException();
1463 }
1464
1465 void SAL_CALL FSStorage::removeStreamElementByHierarchicalName( const OUString& sStreamPath )
1466         throw ( embed::InvalidStorageException,
1467                 lang::IllegalArgumentException,
1468                 container::NoSuchElementException,
1469                 io::IOException,
1470                 embed::StorageWrappedTargetException,
1471                 uno::RuntimeException, std::exception )
1472 {
1473     ::osl::MutexGuard aGuard( m_aMutex );
1474
1475     if ( !m_pImpl )
1476         throw lang::DisposedException();
1477
1478     if ( !GetContent() )
1479         throw io::IOException(); // TODO: error handling
1480
1481     // TODO/LATER: may need possibility to create folder if it was removed, since the folder can not be locked
1482     INetURLObject aBaseURL( m_pImpl->m_aURL );
1483     if ( !aBaseURL.setFinalSlash() )
1484         throw uno::RuntimeException();
1485
1486     OUString aFileURL = INetURLObject::GetAbsURL(
1487                 aBaseURL.GetMainURL( INetURLObject::NO_DECODE ),
1488                 sStreamPath );
1489
1490     if ( !::utl::UCBContentHelper::IsDocument( aFileURL ) )
1491     {
1492         if ( ::utl::UCBContentHelper::IsFolder( aFileURL ) )
1493             throw lang::IllegalArgumentException();
1494         else
1495             throw container::NoSuchElementException(); // TODO:
1496     }
1497
1498     if ( !::utl::UCBContentHelper::Kill( aFileURL ) )
1499         throw io::IOException(); // TODO: error handling
1500 }
1501
1502
1503 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */