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