/* -*- 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: */