diff options
Diffstat (limited to 'sot/source/sdstor/stgdir.cxx')
| -rw-r--r-- | sot/source/sdstor/stgdir.cxx | 938 |
1 files changed, 938 insertions, 0 deletions
diff --git a/sot/source/sdstor/stgdir.cxx b/sot/source/sdstor/stgdir.cxx new file mode 100644 index 0000000000..69ca094f37 --- /dev/null +++ b/sot/source/sdstor/stgdir.cxx @@ -0,0 +1,938 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + + +#include <sot/stg.hxx> +#include "stgelem.hxx" +#include "stgstrms.hxx" +#include "stgdir.hxx" +#include "stgio.hxx" + +#include <osl/diagnose.h> +#include <sal/log.hxx> + +#include <memory> + +//////////////////////////// class StgDirEntry + +// This class holds the dir entry data and maintains dirty flags for both +// the entry and the data. + +// Transacted mode for streams: On the first write, a temp stream pTmpStrm +// is created and operated on. A commit moves pTmpStrm to pCurStrm, which +// is used for subsequent reads. A new write creates a new copy of pTmpStrm +// based on pCurStrm. Reverting throws away pTmpStrm. +// Transacted mode for storages: A copy of the dir ents is kept in aSave. +// Committing means copying aEntry to aSave. Reverting means to copy aSave +// to aEntry, delete newly created entries and to reactivate removed entries. + +// Problem of implementation: No hierarchical commits. Therefore only +// overall transaction-oriented or direct. + +StgDirEntry::StgDirEntry( const void* pBuffer, sal_uInt32 nBufferLen, sal_uInt64 nUnderlyingStreamSize, bool * pbOk ) +{ + *pbOk = m_aEntry.Load( pBuffer, nBufferLen, nUnderlyingStreamSize ); + + InitMembers(); +} + +StgDirEntry::StgDirEntry( const StgEntry& r ) : m_aEntry( r ) +{ + InitMembers(); +} + +// Helper for all ctors + +void StgDirEntry::InitMembers() +{ + m_aSave = m_aEntry; + m_pUp = + m_pDown = nullptr; + m_pStgStrm = nullptr; + m_pCurStrm = + m_pTmpStrm = nullptr; + m_nPos = + m_nEntry = + m_nRefCnt = 0; + m_nMode = StreamMode::READ; + m_bDirect = true; + m_bInvalid = + m_bRemoved = + m_bTemp = + m_bDirty = + m_bZombie = false; +} + +StgDirEntry::~StgDirEntry() +{ + Close(); + delete m_pCurStrm; + delete m_pStgStrm; + delete m_pDown; +} + +// Comparison function + +sal_Int32 StgDirEntry::Compare( const StgAvlNode* p ) const +{ + sal_Int32 nResult = -1; + if ( p ) + { + const StgDirEntry* pEntry = static_cast<const StgDirEntry*>(p); + nResult = m_aEntry.Compare( pEntry->m_aEntry ); + } + return nResult; +} + +// Enumerate the entry numbers. +// n is incremented to show the total # of entries. +// These number are later used as page numbers when storing +// the TOC tree into the TOC stream. Remember that aSave is +// stored, not aEntry. + +void StgDirEntry::Enum( sal_Int32& n ) +{ + sal_Int32 nLeft = STG_FREE, nRight = STG_FREE, nDown = STG_FREE; + m_nEntry = n++; + if( m_pLeft ) + { + static_cast<StgDirEntry*>(m_pLeft)->Enum( n ); + nLeft = static_cast<StgDirEntry*>(m_pLeft)->m_nEntry; + } + if( m_pRight ) + { + static_cast<StgDirEntry*>(m_pRight)->Enum( n ); + nRight = static_cast<StgDirEntry*>(m_pRight)->m_nEntry; + } + if( m_pDown ) + { + m_pDown->Enum( n ); nDown = m_pDown->m_nEntry; + } + m_aSave.SetLeaf( STG_LEFT, nLeft ); + m_aSave.SetLeaf( STG_RIGHT, nRight ); + m_aSave.SetLeaf( STG_CHILD, nDown ); +} + +// Delete all temporary entries before writing the TOC stream. +// Until now Deltemp is never called with bForce True + +void StgDirEntry::DelTemp( bool bForce ) +{ + if( m_pLeft ) + static_cast<StgDirEntry*>(m_pLeft)->DelTemp( false ); + if( m_pRight ) + static_cast<StgDirEntry*>(m_pRight)->DelTemp( false ); + if( m_pDown ) + { + // If the storage is dead, of course all elements are dead, too + if( m_bInvalid && m_aEntry.GetType() == STG_STORAGE ) + bForce = true; + m_pDown->DelTemp( bForce ); + } + if( !( bForce || m_bInvalid ) || ( m_aEntry.GetType() == STG_ROOT ) ) + return; + + Close(); + if( m_pUp ) + { + // this deletes the element if refcnt == 0! + bool bDel = m_nRefCnt == 0; + StgAvlNode::Remove( reinterpret_cast<StgAvlNode**>(&m_pUp->m_pDown), this, bDel ); + if( !bDel ) + { + m_pLeft = m_pRight = m_pDown = nullptr; + m_bInvalid = m_bZombie = true; + } + } +} + +// Save the tree into the given dir stream + +bool StgDirEntry::Store( StgDirStrm& rStrm ) +{ + void* pEntry = rStrm.GetEntry( m_nEntry, true ); + if( !pEntry ) + return false; + // Do not store the current (maybe not committed) entry + m_aSave.Store( pEntry ); + if( m_pLeft ) + if( !static_cast<StgDirEntry*>(m_pLeft)->Store( rStrm ) ) + return false; + if( m_pRight ) + if( !static_cast<StgDirEntry*>(m_pRight)->Store( rStrm ) ) + return false; + if( m_pDown && !m_pDown->Store( rStrm ) ) + return false; + return true; +} + +bool StgDirEntry::StoreStream( StgIo& rIo ) +{ + if( m_aEntry.GetType() == STG_STREAM || m_aEntry.GetType() == STG_ROOT ) + { + if( m_bInvalid ) + { + // Delete the stream if needed + if( !m_pStgStrm ) + { + OpenStream( rIo ); + delete m_pStgStrm; + m_pStgStrm = nullptr; + } + else + m_pStgStrm->SetSize( 0 ); + } + // or write the data stream + else if( !Tmp2Strm() ) + return false; + } + return true; +} + +// Save all dirty streams + +bool StgDirEntry::StoreStreams( StgIo& rIo ) +{ + if( !StoreStream( rIo ) ) + return false; + if( m_pLeft ) + if( !static_cast<StgDirEntry*>(m_pLeft)->StoreStreams( rIo ) ) + return false; + if( m_pRight ) + if( !static_cast<StgDirEntry*>(m_pRight)->StoreStreams( rIo ) ) + return false; + if( m_pDown ) + if( !m_pDown->StoreStreams( rIo ) ) + return false; + return true; +} + +// Revert all directory entries after failure to write the TOC stream + +void StgDirEntry::RevertAll() +{ + m_aEntry = m_aSave; + if( m_pLeft ) + static_cast<StgDirEntry*>(m_pLeft)->RevertAll(); + if( m_pRight ) + static_cast<StgDirEntry*>(m_pRight)->RevertAll(); + if( m_pDown ) + m_pDown->RevertAll(); +} + +// Look if any element of the tree is dirty + +bool StgDirEntry::IsDirty() +{ + if( m_bDirty || m_bInvalid ) + return true; + if( m_pLeft && static_cast<StgDirEntry*>(m_pLeft)->IsDirty() ) + return true; + if( m_pRight && static_cast<StgDirEntry*>(m_pRight)->IsDirty() ) + return true; + if( m_pDown && m_pDown->IsDirty() ) + return true; + return false; +} + +// Set up a stream. + +void StgDirEntry::OpenStream( StgIo& rIo ) +{ + sal_Int32 nThreshold = static_cast<sal_uInt16>(rIo.m_aHdr.GetThreshold()); + delete m_pStgStrm; + if( m_aEntry.GetSize() < nThreshold ) + m_pStgStrm = new StgSmallStrm( rIo, *this ); + else + m_pStgStrm = new StgDataStrm( rIo, *this ); + if( m_bInvalid && m_aEntry.GetSize() ) + { + // This entry has invalid data, so delete that data + SetSize( 0 ); +// bRemoved = bInvalid = false; + } + m_nPos = 0; +} + +// Close the open stream without committing. If the entry is marked as +// temporary, delete it. +// Do not delete pCurStrm here! +// (TLX:??? At least pStgStrm must be deleted.) + +void StgDirEntry::Close() +{ + delete m_pTmpStrm; + m_pTmpStrm = nullptr; +// nRefCnt = 0; + m_bInvalid = m_bTemp; +} + +// Get the current stream size + +sal_Int32 StgDirEntry::GetSize() const +{ + sal_Int32 n; + if( m_pTmpStrm ) + n = m_pTmpStrm->GetSize(); + else if( m_pCurStrm ) + n = m_pCurStrm->GetSize(); + else n = m_aEntry.GetSize(); + return n; +} + +// Set the stream size. This means also creating a temp stream. + +bool StgDirEntry::SetSize( sal_Int32 nNewSize ) +{ + if ( + !( m_nMode & StreamMode::WRITE ) || + (!m_bDirect && !m_pTmpStrm && !Strm2Tmp()) + ) + { + return false; + } + + if( nNewSize < m_nPos ) + m_nPos = nNewSize; + if( m_pTmpStrm ) + { + m_pTmpStrm->SetSize( nNewSize ); + m_pStgStrm->GetIo().SetError( m_pTmpStrm->GetError() ); + return m_pTmpStrm->GetError() == ERRCODE_NONE; + } + else + { + OSL_ENSURE( m_pStgStrm, "The pointer may not be NULL!" ); + if ( !m_pStgStrm ) + return false; + + bool bRes = false; + StgIo& rIo = m_pStgStrm->GetIo(); + sal_Int32 nThreshold = rIo.m_aHdr.GetThreshold(); + // ensure the correct storage stream! + StgStrm* pOld = nullptr; + sal_uInt16 nOldSize = 0; + if( nNewSize >= nThreshold && m_pStgStrm->IsSmallStrm() ) + { + pOld = m_pStgStrm; + nOldSize = static_cast<sal_uInt16>(pOld->GetSize()); + m_pStgStrm = new StgDataStrm( rIo, STG_EOF, 0 ); + } + else if( nNewSize < nThreshold && !m_pStgStrm->IsSmallStrm() ) + { + pOld = m_pStgStrm; + nOldSize = static_cast<sal_uInt16>(nNewSize); + m_pStgStrm = new StgSmallStrm( rIo, STG_EOF ); + } + // now set the new size + if( m_pStgStrm->SetSize( nNewSize ) ) + { + // did we create a new stream? + if( pOld ) + { + // if so, we probably need to copy the old data + if( nOldSize ) + { + std::unique_ptr<sal_uInt8[]> pBuf(new sal_uInt8[ nOldSize ]); + pOld->Pos2Page( 0 ); + m_pStgStrm->Pos2Page( 0 ); + if( pOld->Read( pBuf.get(), nOldSize ) + && m_pStgStrm->Write( pBuf.get(), nOldSize ) ) + bRes = true; + } + else + bRes = true; + if( bRes ) + { + pOld->SetSize( 0 ); + delete pOld; + m_pStgStrm->Pos2Page( m_nPos ); + m_pStgStrm->SetEntry( *this ); + } + else + { + m_pStgStrm->SetSize( 0 ); + delete m_pStgStrm; + m_pStgStrm = pOld; + } + } + else + { + m_pStgStrm->Pos2Page( m_nPos ); + bRes = true; + } + } + return bRes; + } +} + +// Seek. On negative values, seek to EOF. + +sal_Int32 StgDirEntry::Seek( sal_Int32 nNew ) +{ + if( m_pTmpStrm ) + { + if( nNew < 0 ) + nNew = m_pTmpStrm->GetSize(); + nNew = m_pTmpStrm->Seek( nNew ); + } + else if( m_pCurStrm ) + { + if( nNew < 0 ) + nNew = m_pCurStrm->GetSize(); + nNew = m_pCurStrm->Seek( nNew ); + } + else + { + OSL_ENSURE( m_pStgStrm, "The pointer may not be NULL!" ); + if ( !m_pStgStrm ) + return m_nPos; + + sal_Int32 nSize = m_aEntry.GetSize(); + + if( nNew < 0 ) + nNew = nSize; + + // try to enlarge, readonly streams do not allow this + if( nNew > nSize ) + { + if ( !( m_nMode & StreamMode::WRITE ) || !SetSize( nNew ) ) + { + return m_nPos; + } + else + return Seek( nNew ); + } + m_pStgStrm->Pos2Page( nNew ); + nNew = m_pStgStrm->GetPos(); + } + + m_nPos = nNew; + return m_nPos; +} + +// Read + +sal_Int32 StgDirEntry::Read( void* p, sal_Int32 nLen ) +{ + if( nLen <= 0 ) + return 0; + if( m_pTmpStrm ) + nLen = m_pTmpStrm->ReadBytes( p, nLen ); + else if( m_pCurStrm ) + nLen = m_pCurStrm->ReadBytes( p, nLen ); + else + { + OSL_ENSURE( m_pStgStrm, "The pointer may not be NULL!" ); + if ( !m_pStgStrm ) + return 0; + + nLen = m_pStgStrm->Read( p, nLen ); + } + + m_nPos += nLen; + return nLen; +} + +// Write + +sal_Int32 StgDirEntry::Write( const void* p, sal_Int32 nLen ) +{ + if( nLen <= 0 || !( m_nMode & StreamMode::WRITE ) ) + return 0; + + // Was this stream committed internally and reopened in direct mode? + if( m_bDirect && ( m_pCurStrm || m_pTmpStrm ) && !Tmp2Strm() ) + return 0; + // Is this stream opened in transacted mode? Do we have to make a copy? + if( !m_bDirect && !m_pTmpStrm && !Strm2Tmp() ) + return 0; + + OSL_ENSURE( m_pStgStrm, "The pointer may not be NULL!" ); + if ( !m_pStgStrm ) + return 0; + + if( m_pTmpStrm ) + { + nLen = m_pTmpStrm->WriteBytes( p, nLen ); + m_pStgStrm->GetIo().SetError( m_pTmpStrm->GetError() ); + } + else + { + sal_Int32 nNew = m_nPos + nLen; + if( nNew > m_pStgStrm->GetSize() ) + { + if( !SetSize( nNew ) ) + return 0; + m_pStgStrm->Pos2Page( m_nPos ); + } + nLen = m_pStgStrm->Write( p, nLen ); + } + m_nPos += nLen; + return nLen; +} + +void StgDirEntry::Copy( BaseStorageStream& rDest ) +{ + sal_Int32 n = GetSize(); + if( !(rDest.SetSize( n ) && n) ) + return; + + sal_uInt64 Pos = rDest.Tell(); + sal_uInt8 aTempBytes[ 4096 ]; + void* p = static_cast<void*>( aTempBytes ); + Seek( 0 ); + rDest.Seek( 0 ); + while( n ) + { + sal_Int32 nn = n; + if( nn > 4096 ) + nn = 4096; + if( Read( p, nn ) != nn ) + break; + if( sal::static_int_cast<sal_Int32>(rDest.Write( p, nn )) != nn ) + break; + n -= nn; + } + rDest.Seek( Pos ); // ?! Seems to be undocumented ! +} + +// Commit this entry + +bool StgDirEntry::Commit() +{ + // OSL_ENSURE( nMode & StreamMode::WRITE, "Trying to commit readonly stream!" ); + + m_aSave = m_aEntry; + bool bRes = true; + if( m_aEntry.GetType() == STG_STREAM ) + { + if( m_pTmpStrm ) + { + delete m_pCurStrm; + m_pCurStrm = m_pTmpStrm; + m_pTmpStrm = nullptr; + } + if( m_bRemoved ) + // Delete the stream if needed + if( m_pStgStrm ) + m_pStgStrm->SetSize( 0 ); + } + else if( m_aEntry.GetType() == STG_STORAGE && m_bDirect && bRes ) + { + StgIterator aIter( *this ); + for( StgDirEntry* p = aIter.First(); p && bRes; p = aIter.Next() ) + bRes = p->Commit(); + } + return bRes; +} + +// Copy the stg stream to the temp stream + +bool StgDirEntry::Strm2Tmp() +{ + if( !m_pTmpStrm ) + { + sal_uInt64 n = 0; + if( m_pCurStrm ) + { + // It was already committed once + m_pTmpStrm = new StgTmpStrm; + if( m_pTmpStrm->GetError() == ERRCODE_NONE && m_pTmpStrm->Copy( *m_pCurStrm ) ) + return true; + n = 1; // indicates error + } + else + { + n = m_aEntry.GetSize(); + m_pTmpStrm = new StgTmpStrm( n ); + if( m_pTmpStrm->GetError() == ERRCODE_NONE ) + { + if( n ) + { + OSL_ENSURE( m_pStgStrm, "The pointer may not be NULL!" ); + if ( !m_pStgStrm ) + return false; + + sal_uInt8 aTempBytes[ 4096 ]; + void* p = static_cast<void*>( aTempBytes ); + m_pStgStrm->Pos2Page( 0 ); + while( n ) + { + sal_uInt64 nn = n; + if( nn > 4096 ) + nn = 4096; + if( static_cast<sal_uInt64>(m_pStgStrm->Read( p, nn )) != nn ) + break; + if (m_pTmpStrm->WriteBytes( p, nn ) != nn) + break; + n -= nn; + } + m_pStgStrm->Pos2Page( m_nPos ); + m_pTmpStrm->Seek( m_nPos ); + } + } + else + n = 1; + } + + if( n ) + { + OSL_ENSURE( m_pStgStrm, "The pointer may not be NULL!" ); + if ( m_pStgStrm ) + m_pStgStrm->GetIo().SetError( m_pTmpStrm->GetError() ); + + delete m_pTmpStrm; + m_pTmpStrm = nullptr; + return false; + } + } + return true; +} + +// Copy the temp stream to the stg stream during the final commit + +bool StgDirEntry::Tmp2Strm() +{ + // We did commit once, but have not written since then + if( !m_pTmpStrm ) + { + m_pTmpStrm = m_pCurStrm; + m_pCurStrm = nullptr; + } + if( m_pTmpStrm ) + { + OSL_ENSURE( m_pStgStrm, "The pointer may not be NULL!" ); + if ( !m_pStgStrm ) + return false; + sal_uInt64 n = m_pTmpStrm->GetSize(); + std::unique_ptr<StgStrm> pNewStrm; + StgIo& rIo = m_pStgStrm->GetIo(); + sal_uInt64 nThreshold = rIo.m_aHdr.GetThreshold(); + if( n < nThreshold ) + pNewStrm.reset(new StgSmallStrm( rIo, STG_EOF )); + else + pNewStrm.reset(new StgDataStrm( rIo, STG_EOF )); + if( pNewStrm->SetSize( n ) ) + { + sal_uInt8 p[ 4096 ]; + m_pTmpStrm->Seek( 0 ); + while( n ) + { + sal_uInt64 nn = n; + if( nn > 4096 ) + nn = 4096; + if (m_pTmpStrm->ReadBytes( p, nn ) != nn) + break; + if( static_cast<sal_uInt64>(pNewStrm->Write( p, nn )) != nn ) + break; + n -= nn; + } + if( n ) + { + m_pTmpStrm->Seek( m_nPos ); + m_pStgStrm->GetIo().SetError( m_pTmpStrm->GetError() ); + return false; + } + else + { + m_pStgStrm->SetSize( 0 ); + delete m_pStgStrm; + m_pStgStrm = pNewStrm.release(); + m_pStgStrm->SetEntry(*this); + m_pStgStrm->Pos2Page(m_nPos); + delete m_pTmpStrm; + delete m_pCurStrm; + m_pTmpStrm = m_pCurStrm = nullptr; + m_aSave = m_aEntry; + } + } + } + return true; +} + +// Invalidate all open entries by setting the RefCount to 0. If the bDel +// flag is set, also set the invalid flag to indicate deletion during the +// next dir stream flush. + +void StgDirEntry::Invalidate( bool bDel ) +{ +// nRefCnt = 0; + if( bDel ) + m_bRemoved = m_bInvalid = true; + switch( m_aEntry.GetType() ) + { + case STG_STORAGE: + case STG_ROOT: + { + StgIterator aIter( *this ); + for( StgDirEntry* p = aIter.First(); p; p = aIter.Next() ) + p->Invalidate( bDel ); + break; + } + default: + break; + } +} + +///////////////////////////// class StgDirStrm + +// This specialized stream is the maintenance stream for the directory tree. + +StgDirStrm::StgDirStrm( StgIo& r ) + : StgDataStrm( r, r.m_aHdr.GetTOCStart(), -1 ) + , m_pRoot( nullptr ) +{ + if( r.GetError() ) + return; + if( m_nStart == STG_EOF ) + { + StgEntry aRoot; + aRoot.Init(); + static constexpr OUStringLiteral sRootEntry = u"Root Entry"; + aRoot.SetName( sRootEntry ); + aRoot.SetType( STG_ROOT ); + m_pRoot = new StgDirEntry( std::move(aRoot) ); + m_pRoot->SetDirty(); + } + else + { + // temporarily use this instance as owner, so + // the TOC pages can be removed. + m_pEntry = reinterpret_cast<StgDirEntry*>(this); // just for a bit pattern + SetupEntry( 0, m_pRoot ); + m_pEntry = nullptr; + } +} + +StgDirStrm::~StgDirStrm() +{ + delete m_pRoot; +} + +// Recursively parse the directory tree during reading the TOC stream + +void StgDirStrm::SetupEntry( sal_Int32 n, StgDirEntry* pUpper ) +{ + void* p = ( n == STG_FREE ) ? nullptr : GetEntry( n, false ); + if( !p ) + return; + + SvStream *pUnderlyingStream = m_rIo.GetStrm(); + sal_uInt64 nUnderlyingStreamSize = pUnderlyingStream->TellEnd(); + + bool bOk(false); + std::unique_ptr<StgDirEntry> pCur(new StgDirEntry( p, STGENTRY_SIZE, nUnderlyingStreamSize, &bOk )); + + if( !bOk ) + { + m_rIo.SetError( SVSTREAM_GENERALERROR ); + // an error occurred + return; + } + + // better it is + if( !pUpper ) + pCur->m_aEntry.SetType( STG_ROOT ); + + sal_Int32 nLeft = pCur->m_aEntry.GetLeaf( STG_LEFT ); + sal_Int32 nRight = pCur->m_aEntry.GetLeaf( STG_RIGHT ); + // substorage? + sal_Int32 nLeaf = STG_FREE; + if( pCur->m_aEntry.GetType() == STG_STORAGE || pCur->m_aEntry.GetType() == STG_ROOT ) + { + nLeaf = pCur->m_aEntry.GetLeaf( STG_CHILD ); + if (nLeaf != STG_FREE && nLeaf == n) + { + m_rIo.SetError( SVSTREAM_GENERALERROR ); + return; + } + } + + if( !(nLeaf != 0 && nLeft != 0 && nRight != 0) ) + return; + + //fdo#41642 + StgDirEntry *pUp = pUpper; + while (pUp) + { + if (pUp->m_aEntry.GetLeaf(STG_CHILD) == nLeaf) + { + SAL_WARN("sot", "Leaf node of upper StgDirEntry is same as current StgDirEntry's leaf node. Circular entry chain, discarding link"); + return; + } + pUp = pUp->m_pUp; + } + + if( StgAvlNode::Insert + ( reinterpret_cast<StgAvlNode**>( pUpper ? &pUpper->m_pDown : &m_pRoot ), pCur.get() ) ) + { + pCur->m_pUp = pUpper; + } + else + { + // bnc#682484: There are some really broken docs out there + // that contain duplicate entries in 'Directory' section + // so don't set the error flag here and just skip those + // (was: rIo.SetError( SVSTREAM_CANNOT_MAKE );) + return; + } + SetupEntry( nLeft, pUpper ); + SetupEntry( nRight, pUpper ); + SetupEntry( nLeaf, pCur.release() ); +} + +// Extend or shrink the directory stream. + +bool StgDirStrm::SetSize( sal_Int32 nBytes ) +{ + // Always allocate full pages + if ( nBytes < 0 ) + nBytes = 0; + + nBytes = ( ( nBytes + m_nPageSize - 1 ) / m_nPageSize ) * m_nPageSize; + return StgStrm::SetSize( nBytes ); +} + +// Save the TOC stream into a new substream after saving all data streams + +bool StgDirStrm::Store() +{ + if( !m_pRoot || !m_pRoot->IsDirty() ) + return true; + if( !m_pRoot->StoreStreams( m_rIo ) ) + return false; + // After writing all streams, the data FAT stream has changed, + // so we have to commit the root again + m_pRoot->Commit(); + // We want a completely new stream, so fake an empty stream + sal_Int32 nOldStart = m_nStart; // save for later deletion + sal_Int32 nOldSize = m_nSize; + m_nStart = m_nPage = STG_EOF; + m_nSize = 0; + SetPos(0, true); + m_nOffset = 0; + // Delete all temporary entries + m_pRoot->DelTemp( false ); + // set the entry numbers + sal_Int32 n = 0; + m_pRoot->Enum( n ); + if( !SetSize( n * STGENTRY_SIZE ) ) + { + m_nStart = nOldStart; m_nSize = nOldSize; + m_pRoot->RevertAll(); + return false; + } + // set up the cache elements for the new stream + if( !Copy( STG_FREE, m_nSize ) ) + { + m_pRoot->RevertAll(); + return false; + } + // Write the data to the new stream + if( !m_pRoot->Store( *this ) ) + { + m_pRoot->RevertAll(); + return false; + } + // fill any remaining entries with empty data + sal_Int32 ne = m_nSize / STGENTRY_SIZE; + StgEntry aEmpty; + aEmpty.Init(); + while( n < ne ) + { + void* p = GetEntry( n++, true ); + if( !p ) + { + m_pRoot->RevertAll(); + return false; + } + aEmpty.Store( p ); + } + // Now we can release the old stream + m_pFat->FreePages( nOldStart, true ); + m_rIo.m_aHdr.SetTOCStart( m_nStart ); + return true; +} + +// Get a dir entry. + +void* StgDirStrm::GetEntry( sal_Int32 n, bool bDirty ) +{ + return n < 0 || n >= m_nSize / STGENTRY_SIZE + ? nullptr : GetPtr( n * STGENTRY_SIZE, bDirty ); +} + +// Find a dir entry. + +StgDirEntry* StgDirStrm::Find( StgDirEntry& rStg, const OUString& rName ) +{ + if( rStg.m_pDown ) + { + StgEntry aEntry; + aEntry.Init(); + aEntry.SetName( rName ); + // Look in the directory attached to the entry + StgDirEntry aTest( std::move(aEntry) ); + return static_cast<StgDirEntry*>( rStg.m_pDown->Find( &aTest ) ); + } + else + return nullptr; +} + +// Create a new entry. + +StgDirEntry* StgDirStrm::Create( StgDirEntry& rStg, const OUString& rName, StgEntryType eType ) +{ + StgEntry aEntry; + aEntry.Init(); + aEntry.SetType( eType ); + aEntry.SetName( rName ); + StgDirEntry* pRes = Find( rStg, rName ); + if( pRes ) + { + if( !pRes->m_bInvalid ) + { + m_rIo.SetError( SVSTREAM_CANNOT_MAKE ); + return nullptr; + } + pRes->m_bInvalid = + pRes->m_bRemoved = + pRes->m_bTemp = false; + pRes->m_bDirty = true; + return pRes; + } + else + { + std::unique_ptr<StgDirEntry> pNewRes(new StgDirEntry( std::move(aEntry) )); + if( StgAvlNode::Insert( reinterpret_cast<StgAvlNode**>(&rStg.m_pDown), pNewRes.get() ) ) + { + pNewRes->m_pUp = &rStg; + pNewRes->m_bDirty = true; + } + else + { + m_rIo.SetError( SVSTREAM_CANNOT_MAKE ); + pNewRes.reset(); + } + return pNewRes.release(); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |