sot/source/sdstor/stg.cxx

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