source/sdstor/stg.cxx

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sot.hxx"

#include <sot/storinfo.hxx>
#include <osl/file.hxx>
#include <tools/tempfile.hxx>
#include <tools/ownlist.hxx>
#include <tools/string.hxx>
#ifndef _TOOLS_FSYS_HXX
#include <tools/fsys.hxx>
#endif
#ifndef _TOOLS_STREAM_HXX
#include <tools/stream.hxx>
#endif
#include <tools/pstm.hxx>
#include <tools/debug.hxx>

#include "sot/stg.hxx"
#include "stgelem.hxx"
#include "stgcache.hxx"
#include "stgstrms.hxx"
#include "stgdir.hxx"
#include "stgio.hxx"
#include "stgole.hxx"

static long nTmpCount = 0;

// The internal open mode is STREAM_READ | STREAM_TRUNC, which is silly
// by itself. It inhibits the checking of sharing modes and is used
// during CopyTo() and MoveTo() for opening a stream in read mode
// although it may be open in DENYALL mode

#define INTERNAL_MODE ( STREAM_READ | STREAM_TRUNC )

///////////////////////// class StorageBase //////////////////////////////

TYPEINIT0( StorageBase );
TYPEINIT1( BaseStorageStream, StorageBase );
TYPEINIT1( BaseStorage, StorageBase );

StorageBase::StorageBase()
    : m_bAutoCommit( sal_False )
{
	m_nMode  = STREAM_READ;
	m_nError = SVSTREAM_OK;
}

StorageBase::~StorageBase()
{
}

// The following three methods are declared as const, since they
// may be called from within a const method.

sal_uLong StorageBase::GetError() const
{
	sal_uLong n = m_nError;
	((StorageBase*) this)->m_nError = SVSTREAM_OK;
	return n;
}

void StorageBase::SetError( sal_uLong n ) const
{
    if( !m_nError )
		((StorageBase*) this)->m_nError = n;
}

void StorageBase::ResetError() const
{
	((StorageBase*) this)->m_nError = SVSTREAM_OK;
}

// Retrieve the underlying SvStream for info purposes

const SvStream* OLEStorageBase::GetSvStream_Impl() const
{
	return pIo ? pIo->GetStrm() : NULL;
}

OLEStorageBase::OLEStorageBase( StgIo* p, StgDirEntry* pe, StreamMode& nMode )
    : nStreamMode( nMode ), pIo( p ), pEntry( pe )
{
    if ( p )
        p->IncRef();
	if( pe )
		pe->nRefCnt++;
}

OLEStorageBase::~OLEStorageBase()
{
	if( pEntry )
	{
		DBG_ASSERT( pEntry->nRefCnt, "RefCount unter 0" );
		if( !--pEntry->nRefCnt )
		{
			if( pEntry->bZombie )
				delete pEntry;
			else
				pEntry->Close();
		}

        pEntry = NULL;
	}


	if( pIo && !pIo->DecRef() )
    {
		delete pIo;
        pIo = NULL;
    }
}

// Validate the instance for I/O

sal_Bool OLEStorageBase::Validate_Impl( sal_Bool bWrite ) const
{
    if( pIo
        && pIo->pTOC
        && pEntry
		&& !pEntry->bInvalid
        &&  ( !bWrite || !pEntry->bDirect || ( nStreamMode & STREAM_WRITE ) ) )
            return sal_True;
	return sal_False;
}

sal_Bool OLEStorageBase::ValidateMode_Impl( StreamMode m, StgDirEntry* p ) const
{
	if( m == INTERNAL_MODE )
		return sal_True;
	sal_uInt16 nCurMode = ( p && p->nRefCnt ) ? p->nMode : 0xFFFF;
	if( ( m & 3 ) == STREAM_READ )
	{
		// only SHARE_DENYWRITE or SHARE_DENYALL allowed
		if( ( ( m & STREAM_SHARE_DENYWRITE )
		   && ( nCurMode & STREAM_SHARE_DENYWRITE ) )
		 || ( ( m & STREAM_SHARE_DENYALL )
		   && ( nCurMode & STREAM_SHARE_DENYALL ) ) )
			return sal_True;
	}
	else
	{
		// only SHARE_DENYALL allowed
		// storages open in r/o mode are OK, since only
		// the commit may fail
		if( ( m & STREAM_SHARE_DENYALL )
		 && ( nCurMode & STREAM_SHARE_DENYALL ) )
			return sal_True;
	}
	return sal_False;
}


//////////////////////// class StorageStream /////////////////////////////

TYPEINIT1( StorageStream, BaseStorageStream );

StorageStream::StorageStream( StgIo* p, StgDirEntry* q, StreamMode m )
             : OLEStorageBase( p, q, m_nMode ), nPos( 0L )
{
    // The dir entry may be 0; this means that the stream is invalid.
    if( q && p )
	{
		if( q->nRefCnt == 1 )
		{
			q->nMode = m;
			q->OpenStream( *p );
		}
	}
    else
        m &= ~STREAM_READWRITE;
	m_nMode = m;
}

StorageStream::~StorageStream()
{
	// Do an auto-commit if the entry is open in direct mode
	if( m_bAutoCommit )
		Commit();
	if( pEntry && pEntry->nRefCnt && pEntry->bDirect && (m_nMode & STREAM_WRITE) )
		pEntry->Commit();
}

sal_Bool StorageStream::Equals( const BaseStorageStream& rStream ) const
{
    const StorageStream* pOther = PTR_CAST( StorageStream, &rStream );
    return pOther && ( pOther->pEntry == pEntry );
}

sal_uLong StorageStream::Read( void* pData, sal_uLong nSize )
{
	if( Validate() )
	{
		pEntry->Seek( nPos );
		nSize = pEntry->Read( pData, (sal_Int32) nSize );
		pIo->MoveError( *this );
		nPos += nSize;
	}
	else
		nSize = 0L;
	return nSize;
}

sal_uLong StorageStream::Write( const void* pData, sal_uLong nSize )
{
	if( Validate( sal_True ) )
	{
		pEntry->Seek( nPos );
		nSize = pEntry->Write( pData, (sal_Int32) nSize );
		pIo->MoveError( *this );
		nPos += nSize;
	}
	else
		nSize = 0L;
	return nSize;
}

sal_uLong StorageStream::Seek( sal_uLong n )
{
	if( Validate() )
		return nPos = pEntry->Seek( n );
	else
		return n;
}

void StorageStream::Flush()
{
	// Flushing means committing, since streams are never transacted
	Commit();
}

sal_Bool StorageStream::SetSize( sal_uLong nNewSize )
{
    if( Validate( sal_True ) )
	{
		sal_Bool b = pEntry->SetSize( (sal_Int32) nNewSize );
		pIo->MoveError( *this );
		return b;
	}
	else
		return sal_False;
}

sal_Bool StorageStream::Commit()
{
	if( !Validate() )
		return sal_False;
	if( !( m_nMode & STREAM_WRITE ) )
	{
		SetError( SVSTREAM_ACCESS_DENIED );
		return sal_False;
	}
	else
    {
		pEntry->Commit();
		pIo->MoveError( *this );
		return Good();
    }
}

sal_Bool StorageStream::Revert()
{
    sal_Bool bResult = sal_False;

    if ( Validate() )
    {
        pEntry->Revert();
        pIo->MoveError( *this );
        bResult = Good();
    }

    return bResult;
}

sal_Bool StorageStream::CopyTo( BaseStorageStream* pDest )
{
    if( !Validate() || !pDest || !pDest->Validate( sal_True ) || Equals( *pDest ) )
		return sal_False;
    pEntry->Copy( *pDest );
	pDest->Commit();
	pIo->MoveError( *this );
	SetError( pDest->GetError() );
	return sal_Bool( Good() && pDest->Good() );
}

const SvStream* StorageStream::GetSvStream() const
{
    return GetSvStream_Impl();
}

sal_Bool StorageStream::Validate( sal_Bool bValidate ) const
{
    sal_Bool bRet = Validate_Impl( bValidate );
    if ( !bRet )
        SetError( SVSTREAM_ACCESS_DENIED );
    return bRet;
}

sal_Bool StorageStream::ValidateMode( StreamMode nMode ) const
{
    sal_Bool bRet = ValidateMode_Impl( nMode, NULL );
    if ( !bRet )
        SetError( SVSTREAM_ACCESS_DENIED );
    return bRet;
}

sal_Bool StorageStream::ValidateMode( StreamMode nMode, StgDirEntry* p ) const
{
    sal_Bool bRet = ValidateMode_Impl( nMode, p );
    if ( !bRet )
        SetError( SVSTREAM_ACCESS_DENIED );
    return bRet;
}

///////////////////////// class SvStorageInfo //////////////////////////////

SvStorageInfo::SvStorageInfo( const StgDirEntry& rE )
{
    rE.aEntry.GetName( aName );
    bStorage = sal_Bool( rE.aEntry.GetType() == STG_STORAGE );
    bStream  = sal_Bool( rE.aEntry.GetType() == STG_STREAM );
    nSize    = bStorage ? 0 : rE.aEntry.GetSize();
}

/////////////////////////// class Storage ////////////////////////////////

sal_Bool Storage::IsStorageFile( const String & rFileName )
{
    StgIo aIo;
    if( aIo.Open( rFileName, STREAM_STD_READ ) )
    	return aIo.Load();
    return sal_False;
}

sal_Bool Storage::IsStorageFile( SvStream* pStream )
{
    sal_Bool bRet = sal_False;

    if ( pStream )
    {
        StgHeader aHdr;
        sal_uLong nPos = pStream->Tell();
        bRet = ( aHdr.Load( *pStream ) && aHdr.Check() );

        // It's not a stream error if it is too small for a OLE storage header
        if ( pStream->GetErrorCode() == ERRCODE_IO_CANTSEEK )
            pStream->ResetError();
        pStream->Seek( nPos );
    }

    return bRet;
}

// Open the storage file. If writing is permitted and the file is not
// a storage file, initialize it.

TYPEINIT1( Storage, BaseStorage );

Storage::Storage( const String& rFile, StreamMode m, sal_Bool bDirect )
       : OLEStorageBase( new StgIo, NULL, m_nMode ), aName( rFile ), bIsRoot( sal_False )
{
	sal_Bool bTemp = sal_False;
	if( !aName.Len() )
	{
		// no name = temporary name!
		aName = TempFile::CreateTempName();
		bTemp = sal_True;
	}
	// the root storage creates the I/O system
    m_nMode = m;
    if( pIo->Open( aName, m ) )
	{
		Init( sal_Bool( ( m & ( STREAM_TRUNC | STREAM_NOCREATE ) ) == STREAM_TRUNC ) );
		if( pEntry )
		{
			pEntry->bDirect = bDirect;
			pEntry->nMode = m;
			pEntry->bTemp = bTemp;
		}
	}
	else
	{
		pIo->MoveError( *this );
		pEntry = NULL;
	}
}

// Create a storage on a given stream.

Storage::Storage( SvStream& r, sal_Bool bDirect )
       : OLEStorageBase( new StgIo, NULL, m_nMode ), bIsRoot( sal_False )
{
	m_nMode = STREAM_READ;
	if( r.IsWritable() )
		m_nMode = STREAM_READ | STREAM_WRITE;
	if( r.GetError() == SVSTREAM_OK )
	{
		pIo->SetStrm( &r, sal_False );
		sal_uLong nSize = r.Seek( STREAM_SEEK_TO_END );
		r.Seek( 0L );
		// Initializing is OK if the stream is empty
		Init( sal_Bool( nSize == 0 ) );
		if( pEntry )
		{
			pEntry->bDirect = bDirect;
			pEntry->nMode = m_nMode;
		}
		pIo->MoveError( *this );
	}
	else
	{
		SetError( r.GetError() );
		pEntry = NULL;
	}
}


Storage::Storage( UCBStorageStream& rStrm, sal_Bool bDirect )
       : OLEStorageBase( new StgIo, NULL, m_nMode ), bIsRoot( sal_False )
{
	m_nMode = STREAM_READ;

	if ( rStrm.GetError() != SVSTREAM_OK )
	{
		SetError( rStrm.GetError() );
		pEntry = NULL;
		return;
	}

	SvStream* pStream = rStrm.GetModifySvStream();
	if ( !pStream )
	{
		OSL_ENSURE( sal_False, "UCBStorageStream can not provide SvStream implementation!\n" );
		SetError( SVSTREAM_GENERALERROR );
		pEntry = NULL;
		return;
	}

	if( pStream->IsWritable() )
		m_nMode = STREAM_READ | STREAM_WRITE;

	pIo->SetStrm( &rStrm );

	sal_uLong nSize = pStream->Seek( STREAM_SEEK_TO_END );
	pStream->Seek( 0L );
	// Initializing is OK if the stream is empty
	Init( sal_Bool( nSize == 0 ) );
	if( pEntry )
	{
		pEntry->bDirect = bDirect;
		pEntry->nMode = m_nMode;
	}

	pIo->MoveError( *this );
}


// Perform common code for both ctors above.

void Storage::Init( sal_Bool bCreate )
{
	pEntry = NULL;
	sal_Bool bHdrLoaded = sal_False;
    bIsRoot = sal_True;

    OSL_ENSURE( pIo, "The pointer may not be empty at this point!" );
	if( pIo->Good() && pIo->GetStrm() )
	{
		sal_uLong nSize = pIo->GetStrm()->Seek( STREAM_SEEK_TO_END );
		pIo->GetStrm()->Seek( 0L );
		if( nSize )
		{
			bHdrLoaded = pIo->Load();
			if( !bHdrLoaded && !bCreate  )
			{
				// File is not a storage and not empty; do not destroy!
				SetError( SVSTREAM_FILEFORMAT_ERROR );
				return;
			}
		}
	}
    // file is a storage, empty or should be overwritten
	pIo->ResetError();
	// we have to set up the data structures, since
	// the file is empty
	if( !bHdrLoaded )
		pIo->Init();
    if( pIo->Good() && pIo->pTOC )
	{
        pEntry = pIo->pTOC->GetRoot();
		pEntry->nRefCnt++;
	}
}

// Internal ctor

Storage::Storage( StgIo* p, StgDirEntry* q, StreamMode m )
       : OLEStorageBase( p, q, m_nMode ), bIsRoot( sal_False )
{
	if( q )
		q->aEntry.GetName( aName );
	else
        m &= ~STREAM_READWRITE;
	m_nMode   = m;
	if( q && q->nRefCnt == 1 )
		q->nMode = m;
}

Storage::~Storage()
{
	// Invalidate all open substorages
	if( m_bAutoCommit )
		Commit();
	if( pEntry )
	{
		// Do an auto-commit if the entry is open in direct mode
		if( pEntry->nRefCnt && pEntry->bDirect && (m_nMode & STREAM_WRITE) )
			Commit();
		if( pEntry->nRefCnt == 1 )
			pEntry->Invalidate();
	}
	// close the stream is root storage
    if( bIsRoot )
        pIo->Close();
	// remove the file if temporary root storage
	if( bIsRoot && pEntry && pEntry->bTemp )
	{
		osl::File::remove( GetName() );
	}
}

const String& Storage::GetName() const
{
	if( !bIsRoot && Validate() )
		pEntry->aEntry.GetName( ((Storage*) this)->aName );
	return aName;
}

// Fill in the info list for this storage

void Storage::FillInfoList( SvStorageInfoList* pList ) const
{
	if( Validate() && pList )
    {
        StgIterator aIter( *pEntry );
        StgDirEntry* p = aIter.First();
        while( p )
        {
            if( !p->bInvalid )
			{
				SvStorageInfo aInfo( *p );
				pList->Append( aInfo );
			}
			p = aIter.Next();
        }
    }
}

// Open or create a substorage

BaseStorage* Storage::OpenUCBStorage( const String& rName, StreamMode m, sal_Bool bDirect )
{
	DBG_ERROR("Not supported!");
/*
	BaseStorage* pStorage = new Storage( pIo, NULL, m );
	SetError( ERRCODE_IO_NOTSUPPORTED );
	return pStorage;
 */
    return OpenStorage( rName, m, bDirect );
}

BaseStorage* Storage::OpenOLEStorage( const String& rName, StreamMode m, sal_Bool bDirect )
{
    return OpenStorage( rName, m, bDirect );
}

BaseStorage* Storage::OpenStorage( const String& rName, StreamMode m, sal_Bool bDirect )
{
    if( !Validate() || !ValidateMode( m ) )
        return new Storage( pIo, NULL, m );
	sal_Bool bSetAutoCommit = sal_False;
	if( bDirect && !pEntry->bDirect )
	{
		bSetAutoCommit = sal_True;
		bDirect = sal_False;
	}

    StgDirEntry* p = pIo->pTOC->Find( *pEntry, rName );
    if( !p )
    {
        if( !( m & STREAM_NOCREATE ) )
        {
			sal_Bool bTemp = sal_False;
			// create a new storage
			String aNewName = rName;
			if( !aNewName.Len() )
			{
				aNewName.AssignAscii( "Temp Stg " );
				aNewName.Append( String::CreateFromInt32( ++nTmpCount ) );
				bTemp = sal_True;
			}
            p = pIo->pTOC->Create( *pEntry, aNewName, STG_STORAGE );
            if( p )
				p->bTemp = bTemp;
        }
        if( !p )
            pIo->SetError( ( m & STREAM_WRITE )
					         ? SVSTREAM_CANNOT_MAKE : SVSTREAM_FILE_NOT_FOUND );
    }
	else if( !ValidateMode( m, p ) )
		p = NULL;
    if( p && p->aEntry.GetType() != STG_STORAGE )
    {
        pIo->SetError( SVSTREAM_FILE_NOT_FOUND );
        p = NULL;
    }

	// Either direct or transacted mode is supported
	if( p && pEntry->nRefCnt == 1 )
		p->bDirect = bDirect;

	// Dont check direct conflict if opening readonly
	if( p && (m & STREAM_WRITE ))
	{
		if( p->bDirect != bDirect )
			SetError( SVSTREAM_ACCESS_DENIED );
	}
	Storage* pStg = new Storage( pIo, p, m );
	pIo->MoveError( *pStg );
	if( m & STREAM_WRITE ) pStg->m_bAutoCommit = sal_True;
	return pStg;
}

// Open a stream

BaseStorageStream* Storage::OpenStream( const String& rName, StreamMode m, sal_Bool,
const ByteString*
#ifdef DBG_UTIL
pB
#endif
)
{
    DBG_ASSERT(!pB, "Encryption not supported");

    if( !Validate() || !ValidateMode( m ) )
        return new StorageStream( pIo, NULL, m );
	StgDirEntry* p = pIo->pTOC->Find( *pEntry, rName );
	sal_Bool bTemp = sal_False;
	if( !p )
    {
        if( !( m & STREAM_NOCREATE ) )
        {
            // create a new stream
			// make a name if the stream is temporary (has no name)
			String aNewName( rName );
			if( !aNewName.Len() )
			{
				aNewName.AssignAscii( "Temp Strm " );
				aNewName.Append( String::CreateFromInt32( ++nTmpCount ) );
				bTemp = sal_True;
			}
            p = pIo->pTOC->Create( *pEntry, aNewName, STG_STREAM );
		}
        if( !p )
            pIo->SetError( ( m & STREAM_WRITE )
						   ? SVSTREAM_CANNOT_MAKE : SVSTREAM_FILE_NOT_FOUND );
    }
	else if( !ValidateMode( m, p ) )
		p = NULL;
    if( p && p->aEntry.GetType() != STG_STREAM )
    {
        pIo->SetError( SVSTREAM_FILE_NOT_FOUND );
        p = NULL;
    }
	if( p )
	{
		p->bTemp = bTemp;
		p->bDirect = pEntry->bDirect;
	}
    StorageStream* pStm = new StorageStream( pIo, p, m );
	if( p && !p->bDirect )
		pStm->SetAutoCommit( sal_True );
	pIo->MoveError( *pStm );
	return pStm;
}

// Delete a stream or substorage by setting the temp bit.

sal_Bool Storage::Remove( const String& rName )
{
	if( !Validate( sal_True ) )
        return sal_False;
    StgDirEntry* p = pIo->pTOC->Find( *pEntry, rName );
	if( p )
	{
		p->Invalidate( sal_True );
		return sal_True;
	}
    else
	{
        SetError( SVSTREAM_FILE_NOT_FOUND );
	    return sal_False;
	}
}

// Rename a storage element

sal_Bool Storage::Rename( const String& rOld, const String& rNew )
{
	if( Validate( sal_True ) )
	{
	    sal_Bool b = pIo->pTOC->Rename( *pEntry, rOld, rNew );
		pIo->MoveError( *this );
		return b;
	}
	else
		return sal_False;
}

// Copy one element

sal_Bool Storage::CopyTo( const String& rElem, BaseStorage* pDest, const String& rNew )
{
    if( !Validate() || !pDest || !pDest->Validate( sal_True ) )
        return sal_False;
	StgDirEntry* pElem = pIo->pTOC->Find( *pEntry, rElem );
    if( pElem )
    {
		/*
		this lines are mysterious !!! MM
        if( !pElem->IsContained( pDest->pEntry ) )
        {
            SetError( SVSTREAM_ACCESS_DENIED );
            return sal_False;
        }
		*/
        if( pElem->aEntry.GetType() == STG_STORAGE )
        {
            // copy the entire storage
            BaseStorage* p1 = OpenStorage( rElem, INTERNAL_MODE );
            BaseStorage* p2 = pDest->OpenOLEStorage( rNew, STREAM_WRITE | STREAM_SHARE_DENYALL, pEntry->bDirect );

            if ( p2 )
            {
                sal_uLong nTmpErr = p2->GetError();
                if( !nTmpErr )
                {
                    p2->SetClassId( p1->GetClassId() );
                    p1->CopyTo( p2 );
                    SetError( p1->GetError() );

                    nTmpErr = p2->GetError();
                    if( !nTmpErr )
                        p2->Commit();
                    else
                        pDest->SetError( nTmpErr );
                }
                else
                    pDest->SetError( nTmpErr );
            }

			delete p1;
			delete p2;
            return sal_Bool( Good() && pDest->Good() );
        }
        else
        {
            // stream copy
            BaseStorageStream* p1 = OpenStream( rElem, INTERNAL_MODE );
            BaseStorageStream* p2 = pDest->OpenStream( rNew, STREAM_WRITE | STREAM_SHARE_DENYALL, pEntry->bDirect );

            if ( p2 )
            {
                sal_uLong nTmpErr = p2->GetError();
                if( !nTmpErr )
                {
                    p1->CopyTo( p2 );
                    SetError( p1->GetError() );

                    nTmpErr = p2->GetError();
                    if( !nTmpErr )
                        p2->Commit();
                    else
                        pDest->SetError( nTmpErr );
                }
                else
                    pDest->SetError( nTmpErr );
            }

			delete p1;
			delete p2;
            return sal_Bool( Good() && pDest->Good() );
        }
    }
    SetError( SVSTREAM_FILE_NOT_FOUND );
    return sal_False;
}

sal_Bool Storage::CopyTo( BaseStorage* pDest ) const
{
    if( !Validate() || !pDest || !pDest->Validate( sal_True ) || Equals( *pDest ) )
    {
        SetError( SVSTREAM_ACCESS_DENIED );
        return sal_False;
    }
    Storage* pThis = (Storage*) this;
	/*
    if( !pThis->pEntry->IsContained( pDest->pEntry ) )
    {
        SetError( SVSTREAM_ACCESS_DENIED );
        return sal_False;
    }
	*/
    pDest->SetClassId( GetClassId() );
    pDest->SetDirty();
    SvStorageInfoList aList;
    FillInfoList( &aList );
	sal_Bool bRes = sal_True;
    for( sal_uInt16 i = 0; i < aList.Count() && bRes; i++ )
    {
        SvStorageInfo& rInfo = aList.GetObject( i );
        bRes = pThis->CopyTo( rInfo.GetName(), pDest, rInfo.GetName() );
    }
	if( !bRes )
		SetError( pDest->GetError() );
    return sal_Bool( Good() && pDest->Good() );
}

// Move one element

sal_Bool Storage::MoveTo( const String& rElem, BaseStorage* pODest, const String& rNew )
{
    if( !Validate() || !pODest || !pODest->Validate( sal_True ) || Equals( *pODest ) )
    {
        SetError( SVSTREAM_ACCESS_DENIED );
        return sal_False;
    }

    StgDirEntry* pElem = pIo->pTOC->Find( *pEntry, rElem );
    if( pElem )
    {
        // Simplest case: both storages share the same file
		sal_Bool bRes;
        Storage *pOther = PTR_CAST( Storage, pODest );
        if( pOther && pIo == pOther->pIo && rElem == rNew )
        {
            Storage *p = (Storage*) pODest;
            Storage *pDest = p;
            // both storages are conventional storages, use implementation dependent code
            if( !pElem->IsContained( pDest->pEntry ) )
            {
				// cyclic move
				SetError( SVSTREAM_ACCESS_DENIED );
                return sal_False;
            }
			bRes = pIo->pTOC->Move( *pEntry, *pDest->pEntry, rNew );
			if( !bRes )
			{
				pIo->MoveError( *this );
				pDest->pIo->MoveError( *pDest );
				sal_uLong nErr = GetError();
				if( !nErr )
					nErr = pDest->GetError();
				SetError( nErr );
				pDest->SetError( nErr );
			}
		}
        else
        {
			bRes = CopyTo( rElem, pODest, rNew );
			if( bRes )
				bRes = Remove( rElem );
		}
		if( !bRes )
			SetError( pIo->GetError() );
		return bRes;
    }
    SetError( SVSTREAM_FILE_NOT_FOUND );
    return sal_False;
}

sal_Bool Storage::IsStorage( const String& rName ) const
{
    if( Validate() )
    {
        StgDirEntry* p = pIo->pTOC->Find( *pEntry, rName );
        if( p )
            return sal_Bool( p->aEntry.GetType() == STG_STORAGE );
    }
    return sal_False;
}

sal_Bool Storage::IsStream( const String& rName ) const
{
    if( Validate() )
    {
        StgDirEntry* p = pIo->pTOC->Find( *pEntry, rName );
        if( p )
            return sal_Bool( p->aEntry.GetType() == STG_STREAM );
    }
    return sal_False;
}

sal_Bool Storage::IsContained( const String& rName ) const
{
    if( Validate() )
        return sal_Bool( pIo->pTOC->Find( *pEntry, rName ) != NULL );
    else
        return sal_False;
}

// Commit all sub-elements within this storage. If this is
// the root, commit the FAT, the TOC and the header as well.

sal_Bool Storage::Commit()
{
	sal_Bool bRes = sal_True;
	if( !Validate() )
		return sal_False;
	if( !( m_nMode & STREAM_WRITE ) )
	{
		SetError( SVSTREAM_ACCESS_DENIED );
		return sal_False;
	}
	else
	{
		// Also commit the sub-streams and Storages
		StgIterator aIter( *pEntry );
		for( StgDirEntry* p = aIter.First(); p && bRes; p = aIter.Next() )
			bRes = p->Commit();
		if( bRes && bIsRoot )
		{
			bRes = pEntry->Commit();
			if( bRes )
				bRes = pIo->CommitAll();
		}
		pIo->MoveError( *this );
	}
	return bRes;
}

sal_Bool Storage::Revert()
{
	return sal_True;
}

///////////////////////////// OLE Support ////////////////////////////////

// Set the storage type

void Storage::SetClass( const SvGlobalName & rClass,
                                sal_uLong nOriginalClipFormat,
                                const String & rUserTypeName )
{
	if( Validate( sal_True ) )
	{
		// set the class name in the root entry
		pEntry->aEntry.SetClassId( (const ClsId&) rClass.GetCLSID() );
		pEntry->SetDirty();
		// then create the streams
		StgCompObjStream aCompObj( *this, sal_True );
		aCompObj.GetClsId() = (const ClsId&) rClass.GetCLSID();
		aCompObj.GetCbFormat() = nOriginalClipFormat;
		aCompObj.GetUserName() = rUserTypeName;
		if( !aCompObj.Store() )
			SetError( aCompObj.GetError() );
		else
		{
			StgOleStream aOle( *this, STREAM_WRITE );
			if( !aOle.Store() )
				SetError( aOle.GetError() );
		}
	}
	else
		SetError( SVSTREAM_ACCESS_DENIED );
}

void Storage::SetConvertClass( const SvGlobalName & rConvertClass,
                                       sal_uLong nOriginalClipFormat,
                                       const String & rUserTypeName )
{
	if( Validate( sal_True ) )
	{
		SetClass( rConvertClass, nOriginalClipFormat, rUserTypeName );
		// plus the convert flag:
		StgOleStream aOle( *this, sal_True );
		aOle.GetFlags() |= 4;
		if( !aOle.Store() )
			SetError( aOle.GetError() );
	}
}

SvGlobalName Storage::GetClassName()
{
	StgCompObjStream aCompObj( *this, sal_False );
	if( aCompObj.Load() )
		return SvGlobalName( (const CLSID&) aCompObj.GetClsId() );
	pIo->ResetError();

	if ( pEntry )
		return SvGlobalName( (const CLSID&) pEntry->aEntry.GetClassId() );

	return SvGlobalName();
}

sal_uLong Storage::GetFormat()
{
	StgCompObjStream aCompObj( *this, sal_False );
	if( aCompObj.Load() )
		return aCompObj.GetCbFormat();
	pIo->ResetError();
	return 0;
}

String Storage::GetUserName()
{
	StgCompObjStream aCompObj( *this, sal_False );
	if( aCompObj.Load() )
		return aCompObj.GetUserName();
	pIo->ResetError();
	return String();
}

sal_Bool Storage::ShouldConvert()
{
	StgOleStream aOle( *this, sal_False );
	if( aOle.Load() )
		return sal_Bool( ( aOle.GetFlags() & 4 ) != 0 );
	else
	{
		pIo->ResetError();
		return sal_False;
	}
}

sal_Bool Storage::ValidateFAT()
{
	Link aLink = StgIo::GetErrorLink();
	ErrCode nErr = pIo->ValidateFATs();
	StgIo::SetErrorLink( aLink );
	return nErr == ERRCODE_NONE;
}

void Storage::SetDirty()
{
    if ( pEntry )
        pEntry->SetDirty();
}

void Storage::SetClassId( const ClsId& rId )
{
    if ( pEntry )
        pEntry->aEntry.SetClassId( rId );
}

const ClsId& Storage::GetClassId() const
{
    if ( pEntry )
        return pEntry->aEntry.GetClassId();

    static ClsId aDummyId = {0,0,0,0,0,0,0,0,0,0,0};
    return aDummyId;
}

const SvStream* Storage::GetSvStream() const
{
    return GetSvStream_Impl();
}

sal_Bool Storage::Validate( sal_Bool bValidate ) const
{
    sal_Bool bRet = Validate_Impl( bValidate );
    if ( !bRet )
        SetError( SVSTREAM_ACCESS_DENIED );
    return bRet;
}

sal_Bool Storage::ValidateMode( StreamMode nMode ) const
{
    sal_Bool bRet = ValidateMode_Impl( nMode );
    if ( !bRet )
        SetError( SVSTREAM_ACCESS_DENIED );
    return bRet;
}

sal_Bool Storage::ValidateMode( StreamMode nMode, StgDirEntry* p ) const
{
    sal_Bool bRet = ValidateMode_Impl( nMode, p );
    if ( !bRet )
        SetError( SVSTREAM_ACCESS_DENIED );
    return bRet;
}

sal_Bool Storage::Equals( const BaseStorage& rStorage ) const
{
    const Storage* pOther = PTR_CAST( Storage, &rStorage );
    return pOther && ( pOther->pEntry == pEntry );
}