sot/source/sdstor/stg.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
  21 #include <sot/storinfo.hxx>
  22 #include <osl/diagnose.h>
  23 #include <osl/file.hxx>
  24 #include <unotools/tempfile.hxx>
  25 #include <tools/stream.hxx>
  26 #include <tools/debug.hxx>
  27
  28 #include <sot/stg.hxx>
  29 #include <utility>
  30 #include "stgelem.hxx"
  31 #include "stgdir.hxx"
  32 #include "stgio.hxx"
  33 #include "stgole.hxx"
  34
  35 static tools::Long nTmpCount = 0;
  36
  37 // The internal open mode is StreamMode::READ | StreamMode::TRUNC, which is silly
  38 // by itself. It inhibits the checking of sharing modes and is used
  39 // during CopyTo() and MoveTo() for opening a stream in read mode
  40 // although it may be open in DENYALL mode
  41
  42 #define INTERNAL_MODE ( StreamMode::READ | StreamMode::TRUNC )
  43
  44 ///////////////////////// class StorageBase
  45
  46
  47 StorageBase::StorageBase()
  48     : m_bAutoCommit( false )
  49 {
  50     m_nMode  = StreamMode::READ;
  51     m_nError = ERRCODE_NONE;
  52 }
  53
  54 StorageBase::~StorageBase()
  55 {
  56 }
  57
  58 // The following three methods are declared as const, since they
  59 // may be called from within a const method.
  60
  61 ErrCode StorageBase::GetError() const
  62 {
  63     const ErrCode n = m_nError;
  64     m_nError = ERRCODE_NONE;
  65     return n;
  66 }
  67
  68 void StorageBase::SetError( ErrCode n ) const
  69 {
  70     if( !m_nError )
  71         m_nError = n;
  72 }
  73
  74 void StorageBase::ResetError() const
  75 {
  76     m_nError = ERRCODE_NONE;
  77 }
  78
  79 OLEStorageBase::OLEStorageBase( StgIo* p, StgDirEntry* pe, StreamMode& nMode )
  80     : nStreamMode( nMode ), pIo( p ), pEntry( pe )
  81 {
  82     if ( p )
  83         p->IncRef();
  84     if( pe )
  85         pe->m_nRefCnt++;
  86 }
  87
  88 OLEStorageBase::~OLEStorageBase()
  89 {
  90     if( pEntry )
  91     {
  92         DBG_ASSERT( pEntry->m_nRefCnt, "RefCount under 0" );
  93         if( !--pEntry->m_nRefCnt )
  94         {
  95             if( pEntry->m_bZombie )
  96                 delete pEntry;
  97             else
  98                 pEntry->Close();
  99         }
 100
 101         pEntry = nullptr;
 102     }
 103
 104
 105     if( pIo && !pIo->DecRef() )
 106     {
 107         delete pIo;
 108         pIo = nullptr;
 109     }
 110 }
 111
 112 // Validate the instance for I/O
 113
 114 bool OLEStorageBase::Validate_Impl( bool bWrite ) const
 115 {
 116     return pIo
 117         && pIo->m_pTOC
 118         && pEntry
 119         && !pEntry->m_bInvalid
 120         &&  ( !bWrite || !pEntry->m_bDirect || ( nStreamMode & StreamMode::WRITE ) );
 121 }
 122
 123 bool OLEStorageBase::ValidateMode_Impl( StreamMode m, StgDirEntry const * p )
 124 {
 125     if( m == INTERNAL_MODE )
 126         return true;
 127     StreamMode nCurMode = ( p && p->m_nRefCnt ) ? p->m_nMode : StreamMode::SHARE_DENYALL;
 128     if( ( m & StreamMode::READWRITE ) == StreamMode::READ )
 129     {
 130         // only SHARE_DENYWRITE or SHARE_DENYALL allowed
 131         if( ( ( m & StreamMode::SHARE_DENYWRITE )
 132            && ( nCurMode & StreamMode::SHARE_DENYWRITE ) )
 133          || ( ( m & StreamMode::SHARE_DENYALL )
 134            && ( nCurMode & StreamMode::SHARE_DENYALL ) ) )
 135             return true;
 136     }
 137     else
 138     {
 139         // only SHARE_DENYALL allowed
 140         // storages open in r/o mode are OK, since only
 141         // the commit may fail
 142         if( ( m & StreamMode::SHARE_DENYALL )
 143          && ( nCurMode & StreamMode::SHARE_DENYALL ) )
 144             return true;
 145     }
 146     return false;
 147 }
 148
 149
 150 //////////////////////// class StorageStream
 151
 152
 153 StorageStream::StorageStream( StgIo* p, StgDirEntry* q, StreamMode m )
 154              : OLEStorageBase( p, q, m_nMode ), nPos( 0 )
 155 {
 156     // The dir entry may be 0; this means that the stream is invalid.
 157     if( q && p )
 158     {
 159         if( q->m_nRefCnt == 1 )
 160         {
 161             q->m_nMode = m;
 162             q->OpenStream( *p );
 163         }
 164     }
 165     else
 166         m &= ~StreamMode::READWRITE;
 167     m_nMode = m;
 168 }
 169
 170 StorageStream::~StorageStream()
 171 {
 172     // Do an auto-commit if the entry is open in direct mode
 173     if( m_bAutoCommit )
 174         Commit();
 175     if( pEntry && pEntry->m_nRefCnt && pEntry->m_bDirect && (m_nMode & StreamMode::WRITE) )
 176         pEntry->Commit();
 177 }
 178
 179 bool StorageStream::Equals( const BaseStorageStream& rStream ) const
 180 {
 181     const StorageStream* pOther =  dynamic_cast<const StorageStream*>( &rStream );
 182     return pOther && ( pOther->pEntry == pEntry );
 183 }
 184
 185 sal_Int32 StorageStream::Read( void* pData, sal_Int32 nSize )
 186 {
 187     if( Validate() )
 188     {
 189         pEntry->Seek( nPos );
 190         nSize = pEntry->Read( pData, nSize );
 191         pIo->MoveError( *this );
 192         nPos += nSize;
 193     }
 194     else
 195         nSize = 0;
 196     return nSize;
 197 }
 198
 199 sal_Int32 StorageStream::Write( const void* pData, sal_Int32 nSize )
 200 {
 201     if( Validate( true ) )
 202     {
 203         pEntry->Seek( nPos );
 204         nSize = pEntry->Write( pData, nSize );
 205         pIo->MoveError( *this );
 206         nPos += nSize;
 207     }
 208     else
 209         nSize = 0;
 210     return nSize;
 211 }
 212
 213 sal_uInt64 StorageStream::Seek( sal_uInt64 n )
 214 {
 215     if( Validate() )
 216     {
 217         nPos = pEntry->Seek( n );
 218         return nPos;
 219     }
 220     else
 221         return n;
 222 }
 223
 224 void StorageStream::Flush()
 225 {
 226     // Flushing means committing, since streams are never transacted
 227     Commit();
 228 }
 229
 230 bool StorageStream::SetSize( sal_uInt64 nNewSize )
 231 {
 232     if( Validate( true ) )
 233     {
 234         bool b = pEntry->SetSize( nNewSize );
 235         pIo->MoveError( *this );
 236         return b;
 237     }
 238     else
 239         return false;
 240 }
 241
 242 sal_uInt64 StorageStream::GetSize() const
 243 {
 244     if( Validate() )
 245         return pEntry->GetSize();
 246     return 0;
 247 }
 248
 249 bool StorageStream::Commit()
 250 {
 251     if( !Validate() )
 252         return false;
 253     if( !( m_nMode & StreamMode::WRITE ) )
 254     {
 255         SetError( SVSTREAM_ACCESS_DENIED );
 256         return false;
 257     }
 258     else
 259     {
 260         pEntry->Commit();
 261         pIo->MoveError( *this );
 262         return Good();
 263     }
 264 }
 265
 266 void StorageStream::CopyTo( BaseStorageStream* pDest )
 267 {
 268     if( !Validate() || !pDest || !pDest->Validate( true ) || Equals( *pDest ) )
 269         return;
 270     pEntry->Copy( *pDest );
 271     pDest->Commit();
 272     pIo->MoveError( *this );
 273     SetError( pDest->GetError() );
 274 }
 275
 276 bool StorageStream::Validate( bool bValidate ) const
 277 {
 278     bool bRet = Validate_Impl( bValidate );
 279     if ( !bRet )
 280         SetError( SVSTREAM_ACCESS_DENIED );
 281     return bRet;
 282 }
 283
 284 bool StorageStream::ValidateMode( StreamMode nMode ) const
 285 {
 286     bool bRet = ValidateMode_Impl( nMode );
 287     if ( !bRet )
 288         SetError( SVSTREAM_ACCESS_DENIED );
 289     return bRet;
 290 }
 291
 292 ///////////////////////// class SvStorageInfo
 293
 294 SvStorageInfo::SvStorageInfo( const StgDirEntry& rE )
 295 {
 296     rE.m_aEntry.GetName( aName );
 297     bStorage = rE.m_aEntry.GetType() == STG_STORAGE;
 298     bStream  = rE.m_aEntry.GetType() == STG_STREAM;
 299     nSize    = bStorage ? 0 : rE.m_aEntry.GetSize();
 300 }
 301
 302 /////////////////////////// class Storage
 303
 304 bool Storage::IsStorageFile( const OUString & rFileName )
 305 {
 306     StgIo aIo;
 307     if( aIo.Open( rFileName, StreamMode::STD_READ ) )
 308         return aIo.Load();
 309     return false;
 310 }
 311
 312 bool Storage::IsStorageFile( SvStream* pStream )
 313 {
 314     bool bRet = false;
 315
 316     if ( pStream )
 317     {
 318         StgHeader aHdr;
 319         sal_uInt64 nPos = pStream->Tell();
 320         bRet = ( aHdr.Load( *pStream ) && aHdr.Check() );
 321
 322         // It's not a stream error if it is too small for an OLE storage header
 323         if ( pStream->GetErrorCode() == ERRCODE_IO_CANTSEEK )
 324             pStream->ResetError();
 325         pStream->Seek( nPos );
 326     }
 327
 328     return bRet;
 329 }
 330
 331 // Open the storage file. If writing is permitted and the file is not
 332 // a storage file, initialize it.
 333
 334
 335 Storage::Storage( OUString aFile, StreamMode m, bool bDirect )
 336     : OLEStorageBase( new StgIo, nullptr, m_nMode )
 337     , aName(std::move( aFile )), bIsRoot( false )
 338 {
 339     bool bTemp = false;
 340     if( aName.isEmpty() )
 341     {
 342         // no name = temporary name!
 343         aName = utl::CreateTempName();
 344         bTemp = true;
 345     }
 346     // the root storage creates the I/O system
 347     m_nMode = m;
 348     if( pIo->Open( aName, m ) )
 349     {
 350         Init( ( m & ( StreamMode::TRUNC | StreamMode::NOCREATE ) ) == StreamMode::TRUNC );
 351         if( pEntry )
 352         {
 353             pEntry->m_bDirect = bDirect;
 354             pEntry->m_nMode = m;
 355             pEntry->m_bTemp = bTemp;
 356         }
 357     }
 358     else
 359     {
 360         pIo->MoveError( *this );
 361         pEntry = nullptr;
 362     }
 363 }
 364
 365 // Create a storage on a given stream.
 366
 367 Storage::Storage( SvStream& r, bool bDirect )
 368     : OLEStorageBase( new StgIo, nullptr, m_nMode )
 369     , bIsRoot( false )
 370 {
 371     m_nMode = StreamMode::READ;
 372     if( r.IsWritable() )
 373         m_nMode = StreamMode::READ | StreamMode::WRITE;
 374     if( r.GetError() == ERRCODE_NONE )
 375     {
 376         pIo->SetStrm( &r, false );
 377         sal_uInt64 nSize = r.TellEnd();
 378         r.Seek( 0 );
 379         // Initializing is OK if the stream is empty
 380         Init( nSize == 0 );
 381         if( pEntry )
 382         {
 383             pEntry->m_bDirect = bDirect;
 384             pEntry->m_nMode = m_nMode;
 385         }
 386         pIo->MoveError( *this );
 387     }
 388     else
 389     {
 390         SetError( r.GetError() );
 391         pEntry = nullptr;
 392     }
 393 }
 394
 395
 396 Storage::Storage( UCBStorageStream& rStrm, bool bDirect )
 397        : OLEStorageBase( new StgIo, nullptr, m_nMode ), bIsRoot( false )
 398 {
 399     m_nMode = StreamMode::READ;
 400
 401     if ( rStrm.GetError() != ERRCODE_NONE )
 402     {
 403         SetError( rStrm.GetError() );
 404         pEntry = nullptr;
 405         return;
 406     }
 407
 408     SvStream* pStream = rStrm.GetModifySvStream();
 409     if ( !pStream )
 410     {
 411         OSL_FAIL( "UCBStorageStream can not provide SvStream implementation!" );
 412         SetError( SVSTREAM_GENERALERROR );
 413         pEntry = nullptr;
 414         return;
 415     }
 416
 417     if( pStream->IsWritable() )
 418         m_nMode = StreamMode::READ | StreamMode::WRITE;
 419
 420     pIo->SetStrm( &rStrm );
 421
 422     sal_uInt64 nSize = pStream->TellEnd();
 423     pStream->Seek( 0 );
 424     // Initializing is OK if the stream is empty
 425     Init( nSize == 0 );
 426     if( pEntry )
 427     {
 428         pEntry->m_bDirect = bDirect;
 429         pEntry->m_nMode = m_nMode;
 430     }
 431
 432     pIo->MoveError( *this );
 433 }
 434
 435
 436 // Perform common code for both ctors above.
 437
 438 void Storage::Init( bool bCreate )
 439 {
 440     pEntry = nullptr;
 441     bool bHdrLoaded = false;
 442     bIsRoot = true;
 443
 444     assert(pIo && "The pointer may not be empty at this point!");
 445     if( pIo->Good() && pIo->GetStrm() )
 446     {
 447         sal_uInt64 nSize = pIo->GetStrm()->TellEnd();
 448         pIo->GetStrm()->Seek( 0 );
 449         if( nSize )
 450         {
 451             bHdrLoaded = pIo->Load();
 452             if( !bHdrLoaded && !bCreate  )
 453             {
 454                 // File is not a storage and not empty; do not destroy!
 455                 SetError( SVSTREAM_FILEFORMAT_ERROR );
 456                 return;
 457             }
 458         }
 459     }
 460     // file is a storage, empty or should be overwritten
 461     pIo->ResetError();
 462     // we have to set up the data structures, since
 463     // the file is empty
 464     if( !bHdrLoaded )
 465         pIo->Init();
 466     if( pIo->Good() && pIo->m_pTOC )
 467     {
 468         pEntry = pIo->m_pTOC->GetRoot();
 469         pEntry->m_nRefCnt++;
 470     }
 471 }
 472
 473 // Internal ctor
 474
 475 Storage::Storage( StgIo* p, StgDirEntry* q, StreamMode m )
 476        : OLEStorageBase( p, q, m_nMode ), bIsRoot( false )
 477 {
 478     if( q )
 479         q->m_aEntry.GetName( aName );
 480     else
 481         m &= ~StreamMode::READWRITE;
 482     m_nMode   = m;
 483     if( q && q->m_nRefCnt == 1 )
 484         q->m_nMode = m;
 485 }
 486
 487 Storage::~Storage()
 488 {
 489     // Invalidate all open substorages
 490     if( m_bAutoCommit )
 491         Commit();
 492     if( pEntry )
 493     {
 494         // Do an auto-commit if the entry is open in direct mode
 495         if( pEntry->m_nRefCnt && pEntry->m_bDirect && (m_nMode & StreamMode::WRITE) )
 496             Commit();
 497         if( pEntry->m_nRefCnt == 1 )
 498             pEntry->Invalidate(false);
 499     }
 500     // close the stream is root storage
 501     if( bIsRoot )
 502         pIo->Close();
 503     // remove the file if temporary root storage
 504     if( bIsRoot && pEntry && pEntry->m_bTemp )
 505     {
 506         osl::File::remove( GetName() );
 507     }
 508 }
 509
 510 const OUString& Storage::GetName() const
 511 {
 512     if( !bIsRoot && Validate() )
 513         pEntry->m_aEntry.GetName( const_cast<Storage*>(this)->aName );
 514     return aName;
 515 }
 516
 517 // Fill in the info list for this storage
 518
 519 void Storage::FillInfoList( SvStorageInfoList* pList ) const
 520 {
 521     if( !(Validate() && pList) )
 522         return;
 523
 524     StgIterator aIter( *pEntry );
 525     StgDirEntry* p = aIter.First();
 526     while( p )
 527     {
 528         if( !p->m_bInvalid )
 529         {
 530             SvStorageInfo aInfo( *p );
 531             pList->push_back( aInfo );
 532         }
 533         p = aIter.Next();
 534     }
 535 }
 536
 537 // Open or create a substorage
 538
 539 BaseStorage* Storage::OpenUCBStorage( const OUString& rName, StreamMode m, bool bDirect )
 540 {
 541     OSL_FAIL("Not supported!");
 542     return OpenStorage( rName, m, bDirect );
 543 }
 544
 545 BaseStorage* Storage::OpenOLEStorage( const OUString& rName, StreamMode m, bool bDirect )
 546 {
 547     return OpenStorage( rName, m, bDirect );
 548 }
 549
 550 BaseStorage* Storage::OpenStorage( const OUString& rName, StreamMode m, bool bDirect )
 551 {
 552     if( !Validate() || !ValidateMode( m ) )
 553         return new Storage( pIo, nullptr, m );
 554     if( bDirect && !pEntry->m_bDirect )
 555         bDirect = false;
 556
 557     StgDirEntry* p = StgDirStrm::Find( *pEntry, rName );
 558     if( !p )
 559     {
 560         if( !( m & StreamMode::NOCREATE ) )
 561         {
 562             bool bTemp = false;
 563             // create a new storage
 564             OUString aNewName = rName;
 565             if( aNewName.isEmpty() )
 566             {
 567                 aNewName = "Temp Stg " + OUString::number( ++nTmpCount );
 568                 bTemp = true;
 569             }
 570             p = pIo->m_pTOC->Create( *pEntry, aNewName, STG_STORAGE );
 571             if( p )
 572                 p->m_bTemp = bTemp;
 573         }
 574         if( !p )
 575             pIo->SetError( ( m & StreamMode::WRITE )
 576                              ? SVSTREAM_CANNOT_MAKE : SVSTREAM_FILE_NOT_FOUND );
 577     }
 578     else if( !ValidateMode( m, p ) )
 579         p = nullptr;
 580     if( p && p->m_aEntry.GetType() != STG_STORAGE )
 581     {
 582         pIo->SetError( SVSTREAM_FILE_NOT_FOUND );
 583         // coverity[overwrite_var] - ownership is not here, but with StgDirStrm
 584         p = nullptr;
 585     }
 586
 587     // Either direct or transacted mode is supported
 588     if( p && pEntry->m_nRefCnt == 1 )
 589         p->m_bDirect = bDirect;
 590
 591     // Don't check direct conflict if opening readonly
 592     if( p && (m & StreamMode::WRITE ))
 593     {
 594         if( p->m_bDirect != bDirect )
 595             SetError( SVSTREAM_ACCESS_DENIED );
 596     }
 597     Storage* pStg = new Storage( pIo, p, m );
 598     pIo->MoveError( *pStg );
 599     if( m & StreamMode::WRITE ) pStg->m_bAutoCommit = true;
 600     return pStg;
 601 }
 602
 603 // Open a stream
 604
 605 BaseStorageStream* Storage::OpenStream( const OUString& rName, StreamMode m, bool )
 606 {
 607     if( !Validate() || !ValidateMode( m ) )
 608         return new StorageStream( pIo, nullptr, m );
 609     StgDirEntry* p = StgDirStrm::Find( *pEntry, rName );
 610     bool bTemp = false;
 611     if( !p )
 612     {
 613         if( !( m & StreamMode::NOCREATE ) )
 614         {
 615             // create a new stream
 616             // make a name if the stream is temporary (has no name)
 617             OUString aNewName( rName );
 618             if( aNewName.isEmpty() )
 619             {
 620                 aNewName = "Temp Strm " + OUString::number( ++nTmpCount );
 621                 bTemp = true;
 622             }
 623             p = pIo->m_pTOC->Create( *pEntry, aNewName, STG_STREAM );
 624         }
 625         if( !p )
 626             pIo->SetError( ( m & StreamMode::WRITE )
 627                            ? SVSTREAM_CANNOT_MAKE : SVSTREAM_FILE_NOT_FOUND );
 628     }
 629     else if( !ValidateMode( m, p ) )
 630         p = nullptr;
 631     // coverity[Resource leak : FALSE] - "Create" method is called with STG_STREAM line 620,
 632     // so we won't enter into this "if" block here.
 633     if( p && p->m_aEntry.GetType() != STG_STREAM )
 634     {
 635         pIo->SetError( SVSTREAM_FILE_NOT_FOUND );
 636         p = nullptr;
 637     }
 638     if( p )
 639     {
 640         p->m_bTemp = bTemp;
 641         p->m_bDirect = pEntry->m_bDirect;
 642     }
 643     StorageStream* pStm = new StorageStream( pIo, p, m );
 644     if( p && !p->m_bDirect )
 645         pStm->SetAutoCommit( true );
 646     pIo->MoveError( *pStm );
 647     return pStm;
 648 }
 649
 650 // Delete a stream or substorage by setting the temp bit.
 651
 652 void Storage::Remove( const OUString& rName )
 653 {
 654     if( !Validate( true ) )
 655         return;
 656     StgDirEntry* p = StgDirStrm::Find( *pEntry, rName );
 657     if( p )
 658     {
 659         p->Invalidate( true );
 660     }
 661     else
 662     {
 663         SetError( SVSTREAM_FILE_NOT_FOUND );
 664     }
 665 }
 666
 667 // Copy one element
 668
 669 bool Storage::CopyTo( const OUString& rElem, BaseStorage* pDest, const OUString& rNew )
 670 {
 671     if( !Validate() || !pDest || !pDest->Validate( true ) )
 672         return false;
 673     StgDirEntry* pElem = StgDirStrm::Find( *pEntry, rElem );
 674     if( pElem )
 675     {
 676         if( pElem->m_aEntry.GetType() == STG_STORAGE )
 677         {
 678             // copy the entire storage
 679             tools::SvRef<BaseStorage> p1 = OpenStorage( rElem, INTERNAL_MODE );
 680             tools::SvRef<BaseStorage> p2 = pDest->OpenOLEStorage( rNew, StreamMode::WRITE | StreamMode::SHARE_DENYALL, pEntry->m_bDirect );
 681
 682             if ( p2 )
 683             {
 684                 ErrCode nTmpErr = p2->GetError();
 685                 if( !nTmpErr )
 686                 {
 687                     p2->SetClassId( p1->GetClassId() );
 688                     p1->CopyTo( *p2 );
 689                     SetError( p1->GetError() );
 690
 691                     nTmpErr = p2->GetError();
 692                     if( !nTmpErr )
 693                         p2->Commit();
 694                     else
 695                         pDest->SetError( nTmpErr );
 696                 }
 697                 else
 698                     pDest->SetError( nTmpErr );
 699             }
 700
 701             return Good() && pDest->Good();
 702         }
 703         else
 704         {
 705             // stream copy
 706             tools::SvRef<BaseStorageStream> p1 = OpenStream( rElem, INTERNAL_MODE );
 707             tools::SvRef<BaseStorageStream> p2 = pDest->OpenStream( rNew, StreamMode::WRITE | StreamMode::SHARE_DENYALL, pEntry->m_bDirect );
 708
 709             if ( p2 )
 710             {
 711                 ErrCode nTmpErr = p2->GetError();
 712                 if( !nTmpErr )
 713                 {
 714                     p1->CopyTo( p2.get() );
 715                     SetError( p1->GetError() );
 716
 717                     nTmpErr = p2->GetError();
 718                     if( !nTmpErr )
 719                         p2->Commit();
 720                     else
 721                         pDest->SetError( nTmpErr );
 722                 }
 723                 else
 724                     pDest->SetError( nTmpErr );
 725             }
 726
 727             return Good() && pDest->Good();
 728         }
 729     }
 730     SetError( SVSTREAM_FILE_NOT_FOUND );
 731     return false;
 732 }
 733
 734 bool Storage::CopyTo( BaseStorage& rDest ) const
 735 {
 736     if( !Validate() || !rDest.Validate( true ) || Equals( rDest ) )
 737     {
 738         SetError( SVSTREAM_ACCESS_DENIED );
 739         return false;
 740     }
 741     Storage* pThis = const_cast<Storage*>(this);
 742     rDest.SetClassId( GetClassId() );
 743     rDest.SetDirty();
 744     SvStorageInfoList aList;
 745     FillInfoList( &aList );
 746     bool bRes = true;
 747     for( size_t i = 0; i < aList.size() && bRes; i++ )
 748     {
 749         SvStorageInfo& rInfo = aList[ i ];
 750         bRes = pThis->CopyTo( rInfo.GetName(), &rDest, rInfo.GetName() );
 751     }
 752     if( !bRes )
 753         SetError( rDest.GetError() );
 754     return Good() && rDest.Good();
 755 }
 756
 757 bool Storage::IsStorage( const OUString& rName ) const
 758 {
 759     if( Validate() )
 760     {
 761         StgDirEntry* p = StgDirStrm::Find( *pEntry, rName );
 762         if( p )
 763             return p->m_aEntry.GetType() == STG_STORAGE;
 764     }
 765     return false;
 766 }
 767
 768 bool Storage::IsStream( const OUString& rName ) const
 769 {
 770     if( Validate() )
 771     {
 772         StgDirEntry* p = StgDirStrm::Find( *pEntry, rName );
 773         if( p )
 774             return p->m_aEntry.GetType() == STG_STREAM;
 775     }
 776     return false;
 777 }
 778
 779 bool Storage::IsContained( const OUString& rName ) const
 780 {
 781     if( Validate() )
 782         return StgDirStrm::Find( *pEntry, rName ) != nullptr;
 783     else
 784         return false;
 785 }
 786
 787 // Commit all sub-elements within this storage. If this is
 788 // the root, commit the FAT, the TOC and the header as well.
 789
 790 bool Storage::Commit()
 791 {
 792     bool bRes = true;
 793     if( !Validate() )
 794         return false;
 795     if( !( m_nMode & StreamMode::WRITE ) )
 796     {
 797         SetError( SVSTREAM_ACCESS_DENIED );
 798         return false;
 799     }
 800     else
 801     {
 802         // Also commit the sub-streams and Storages
 803         StgIterator aIter( *pEntry );
 804         for( StgDirEntry* p = aIter.First(); p && bRes; p = aIter.Next() )
 805             bRes = p->Commit();
 806         if( bRes && bIsRoot )
 807         {
 808             bRes = pEntry->Commit();
 809             if( bRes )
 810                 bRes = pIo->CommitAll();
 811         }
 812         pIo->MoveError( *this );
 813     }
 814     return bRes;
 815 }
 816
 817 bool Storage::Revert()
 818 {
 819     return true;
 820 }
 821
 822 ///////////////////////////// OLE Support
 823
 824 // Set the storage type
 825
 826 void Storage::SetClass( const SvGlobalName & rClass,
 827                         SotClipboardFormatId nOriginalClipFormat,
 828                         const OUString & rUserTypeName )
 829 {
 830     if( Validate( true ) )
 831     {
 832         // set the class name in the root entry
 833         pEntry->m_aEntry.SetClassId( rClass.GetCLSID() );
 834         pEntry->SetDirty();
 835         // then create the streams
 836         StgCompObjStream aCompObj( *this, true );
 837         aCompObj.GetClsId() = rClass.GetCLSID();
 838         aCompObj.GetCbFormat() = nOriginalClipFormat;
 839         aCompObj.GetUserName() = rUserTypeName;
 840         if( !aCompObj.Store() )
 841             SetError( aCompObj.GetError() );
 842         else
 843         {
 844             StgOleStream aOle(*this);
 845             if( !aOle.Store() )
 846                 SetError( aOle.GetError() );
 847         }
 848     }
 849     else
 850         SetError( SVSTREAM_ACCESS_DENIED );
 851 }
 852
 853 SvGlobalName Storage::GetClassName()
 854 {
 855     StgCompObjStream aCompObj( *this, false );
 856     if( aCompObj.Load() )
 857         return SvGlobalName( aCompObj.GetClsId() );
 858     pIo->ResetError();
 859
 860     if ( pEntry )
 861         return SvGlobalName( pEntry->m_aEntry.GetClassId() );
 862
 863     return SvGlobalName();
 864 }
 865
 866 SotClipboardFormatId Storage::GetFormat()
 867 {
 868     StgCompObjStream aCompObj( *this, false );
 869     if( aCompObj.Load() )
 870         return aCompObj.GetCbFormat();
 871     pIo->ResetError();
 872     return SotClipboardFormatId::NONE;
 873 }
 874
 875 OUString Storage::GetUserName()
 876 {
 877     StgCompObjStream aCompObj( *this, false );
 878     if( aCompObj.Load() )
 879         return aCompObj.GetUserName();
 880     pIo->ResetError();
 881     return OUString();
 882 }
 883
 884 bool Storage::ValidateFAT()
 885 {
 886     FatError nErr = pIo->ValidateFATs();
 887     return nErr == FatError::Ok;
 888 }
 889
 890 void Storage::SetDirty()
 891 {
 892     if ( pEntry )
 893         pEntry->SetDirty();
 894 }
 895
 896 void Storage::SetClassId( const ClsId& rId )
 897 {
 898     if ( pEntry )
 899         pEntry->m_aEntry.SetClassId( rId );
 900 }
 901
 902 const ClsId& Storage::GetClassId() const
 903 {
 904     if ( pEntry )
 905         return pEntry->m_aEntry.GetClassId();
 906
 907     static const ClsId aDummyId = {0,0,0,{0,0,0,0,0,0,0,0}};
 908     return aDummyId;
 909 }
 910
 911 bool Storage::Validate( bool bValidate ) const
 912 {
 913     bool bRet = Validate_Impl( bValidate );
 914     if ( !bRet )
 915         SetError( SVSTREAM_ACCESS_DENIED );
 916     return bRet;
 917 }
 918
 919 bool Storage::ValidateMode( StreamMode nMode ) const
 920 {
 921     bool bRet = ValidateMode_Impl( nMode );
 922     if ( !bRet )
 923         SetError( SVSTREAM_ACCESS_DENIED );
 924     return bRet;
 925 }
 926
 927 bool Storage::ValidateMode( StreamMode nMode, StgDirEntry const * p ) const
 928 {
 929     bool bRet = ValidateMode_Impl( nMode, p );
 930     if ( !bRet )
 931         SetError( SVSTREAM_ACCESS_DENIED );
 932     return bRet;
 933 }
 934
 935 bool Storage::Equals( const BaseStorage& rStorage ) const
 936 {
 937     const Storage* pOther =  dynamic_cast<const Storage*>( &rStorage );
 938     return pOther && ( pOther->pEntry == pEntry );
 939 }
 940
 941 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */