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