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