windows-server-2003/inetsrv/query/ntciutil/prpstmgr.cxx

//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1991 - 2002.
//
//  File:       PrpStMgr.cxx
//
//  Contents:   A two-level property store.
//
//  Classes:    CPropStoreManager
//
//  History:    24-Oct-1997   KrishnaN       Created
//
//----------------------------------------------------------------------------

#include <pch.cxx>
#pragma hdrstop

#include <prpstmgr.hxx>
#include <propobj.hxx>
#include <eventlog.hxx>
#include <catalog.hxx>
#include <imprsnat.hxx>
#include <propiter.hxx>

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::CPropStoreManager, public
//
//  Synopsis:   Constructs the class.
//
//  History:    24-Oct-97   KrishnaN       Created.
//              01-Nov-98   KLam           Added cMegToLeaveOnDisk to constructor
//
//----------------------------------------------------------------------------

CPropStoreManager::CPropStoreManager( ULONG cMegToLeaveOnDisk )
        : _pStorage( 0 ),
          _xPrimaryStore( 0 ),
          _xSecondaryStore( 0 ),
          _dwXctionStoreLevel( INVALID_STORE_LEVEL ),
          _cMegToLeaveOnDisk( cMegToLeaveOnDisk )
{
    _xPrimaryStore.Set(new CPropertyStore(*this, PRIMARY_STORE));
    _xSecondaryStore.Set(new CPropertyStore(*this, SECONDARY_STORE));
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::CPropStoreManager, public
//
//  Synopsis:   Constructs the class.
//
//  History:    24-Oct-97   KrishnaN       Created.
//              01-Nov-98   KLam           Added cMegToLeaveOnDisk to constructor
//
//----------------------------------------------------------------------------

CPropStoreManager::CPropStoreManager(CiStorage * pStorage,
                                     CPropertyStore *pPrimaryStore,
                                     CPropertyStore *pSecondaryStore,
                                     ULONG cMegToLeaveOnDisk )
        : _pStorage( pStorage ),
          _dwXctionStoreLevel( INVALID_STORE_LEVEL ),
          _cMegToLeaveOnDisk( cMegToLeaveOnDisk )
{
    _xPrimaryStore.Set( pPrimaryStore );
    _xSecondaryStore.Set( pSecondaryStore );
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::~CPropStoreManager, public
//
//  Synopsis:   Destructs the class.
//
//  History:    24-Oct-97   KrishnaN       Created.
//
//----------------------------------------------------------------------------

CPropStoreManager::~CPropStoreManager()
{
    if ( !_xpsNew.IsNull() )
    {
        //
        // The property stores in xpsnew are owned by the property stores
        // in this instance (the one being destructed) of the property
        // stores.  They're in smart pointers but you can't delete them.
        //

        _xpsNew->_xPrimaryStore.Acquire();
        _xpsNew->_xSecondaryStore.Acquire();
        _xpsNew.Free();
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::Empty
//
//  Synopsis:   Empties out the intitialized members and prepares for a
//              re-init.
//
//  History:    22-Oct-97       KrishnaN   Created
//
//----------------------------------------------------------------------------

void CPropStoreManager::Empty()
{
    _xPrimaryStore->Empty();
    _xSecondaryStore->Empty();
    _pStorage = 0;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::FastInit, public
//
//  Synopsis:   Initialize property store (two-phase construction)
//
//  Arguments:  [pStorage] -- Storage object.
//
//  History:    22-Oct-97    KrishnaN    Created
//
//----------------------------------------------------------------------------

void CPropStoreManager::FastInit( CiStorage * pStorage )
{
    _pStorage = pStorage;
    _xPrimaryStore->FastInit(pStorage);
    _xSecondaryStore->FastInit(pStorage);
}


//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::LongInit
//
//  Synopsis:   If the propstore was dirty when shut down, run the recovery
//              operation.
//
//  Arguments:  [fWasDirty]        -- dirty flag is returned here
//              [cInconsistencies] -- returns number of inconsistencies found
//              [pfnUpdateCallback]-- Callback to be called to update docs during
//                                    recovery. the prop store has no knowledge of
//                                    doc store, so this callback is needed.
//              [pUserData]        -- will be echoed back through callback.
//
//  Returns:
//
//  History:    22-Oct-97     KrishnaN   Created
//
//  Notes:      The propstore is locked for write during recovery, but
//              reads are still permitted.
//
//----------------------------------------------------------------------------

void CPropStoreManager::LongInit( BOOL & fWasDirty, ULONG & cInconsistencies,
                               T_UpdateDoc pfnUpdateCallback, void const *pUserData )
{
    //
    // If at least one of the two stores is dirty, consider both to be dirty
    // and recover from both.
    //

    ciDebugOut(( DEB_ITRACE, "is primary dirty: %d, is secondary dirty %d\n",
                 _xPrimaryStore->IsDirty(), _xSecondaryStore->IsDirty() ));

    ciDebugOut(( DEB_ITRACE, "is backedup mode: %d\n", IsBackedUpMode() ));

    if (IsDirty())
    {
        _xPrimaryStore->_PropStoreInfo.MarkDirty();
        _xSecondaryStore->_PropStoreInfo.MarkDirty();
    }

    //
    // If at least one of them recovered with inconsistencies, both should be
    // considered to be corrupt!
    //

    _xPrimaryStore->LongInit(fWasDirty, cInconsistencies, pfnUpdateCallback, pUserData);

    ciDebugOut(( DEB_ITRACE, "fWas, cIncon: %d, %d\n", fWasDirty, cInconsistencies ));

    if (fWasDirty && cInconsistencies)
    {
        // Propstore is considered corrupt. No point attempting recovery on
        // secondary.

        return;
    }

    _xSecondaryStore->LongInit(fWasDirty, cInconsistencies, pfnUpdateCallback, pUserData);

    ciDebugOut(( DEB_ITRACE, "2nd: fWas, cIncon: %d, %d\n", fWasDirty, cInconsistencies ));

    if (fWasDirty && cInconsistencies)
    {
        // Propstore is still corrupt.
        return;
    }

    // Are both the stores in sync

    // First line defense
    if (_xPrimaryStore->CountRecordsInUse() != _xSecondaryStore->CountRecordsInUse())
    {
        Win4Assert(fWasDirty);
        cInconsistencies = abs((LONG)_xPrimaryStore->CountRecordsInUse() -
                               (LONG)_xSecondaryStore->CountRecordsInUse());
        return;
    }

    // We have done our best to recover from a dirty shutdown. However, in at least one
    // case (bug 132655), it was detected that there was an inconsistency between the
    // two stores. Ensure that we catch such inconsistencies.

    if (IsDirty())
    {
        CPropertyStoreWids iter(*this);

        ULONG iRec = 0;
        const ULONG cTotal = _xPrimaryStore->CountRecordsInUse();

        for ( WORKID wid = iter.WorkId();
              !cInconsistencies && wid != widInvalid;
              wid = iter.LokNextWorkId() )
        {
           iRec++;
           // get the physical store pointed to by the primary top-level record
           CBorrowed BorrowedTopLevel( *(_xSecondaryStore->PhysStore()),
                                       GetSecondaryTopLevelWid(wid),
                                       _xSecondaryStore->RecordsPerPage(),
                                       _xSecondaryStore->RecordSize() );

           COnDiskPropertyRecord * prec = BorrowedTopLevel.Get();
           if (!prec->IsInUse())
               cInconsistencies++;
        }

        if (cInconsistencies)
            return;
    }

    #if 0 // this is really expensive... CIDBG == 1

    else
    {
        ULONG iRec = 0;
        const ULONG cTotal = _xPrimaryStore->CountRecordsInUse();

        CPropertyStoreWids iter(*this);

        for ( WORKID wid = iter.WorkId(); wid != widInvalid; wid = iter.LokNextWorkId() )
        {
           iRec++;
           // get the physical store pointed to by the primary top-level record
           CBorrowed BorrowedTopLevel( *(_xSecondaryStore->PhysStore()),
                                       GetSecondaryTopLevelWid(wid),
                                       _xSecondaryStore->RecordsPerPage(),
                                       _xSecondaryStore->RecordSize() );

           COnDiskPropertyRecord * prec = BorrowedTopLevel.Get();
           Win4Assert(prec->IsInUse());
        }
    }

    #endif // CIDBG

    // All is well. Flush and get on with the business of indexing and searching
    Flush();
} //LongInit

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::BeginTransaction, public
//
//  Synopsis:   Begins a schema transaction. Any existing transaction will be
//              aborted.
//
//  Returns:    Token representing transaction.
//
//  History:    24-Oct-97      KrishnaN       Created.
//              02-Nov-98      KLam           Passed _cMegToLeaveOnDisk to 
//                                            CPropStoreManager
//
//----------------------------------------------------------------------------

ULONG_PTR CPropStoreManager::BeginTransaction()
{
    CLock lock( _mtxWrite );

    // we are not committing, so the fixed pids are ignored.
    if ( !_xpsNew.IsNull() )
        EndTransaction( (ULONG_PTR)_xpsNew.Acquire(), FALSE, pidInvalid, pidInvalid);

    ULONG_PTR ulPrimaryXctionToken = _xPrimaryStore->BeginTransaction();
    ULONG_PTR ulSecondaryXctionToken = _xSecondaryStore->BeginTransaction();

    _xpsNew.Set( new CPropStoreManager( _pStorage,
                                        (CPropertyStore *)ulPrimaryXctionToken,
                                        (CPropertyStore *)ulSecondaryXctionToken,
                                        _cMegToLeaveOnDisk ) );

    // init storelevel used in transaction to unknown.
    _dwXctionStoreLevel = INVALID_STORE_LEVEL;
    return (ULONG_PTR)_xpsNew.GetPointer();
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::Setup, public
//
//  Synopsis:   Setup a property description.  Property may already exist
//              in the cache.
//
//  Arguments:  [pid]        -- Propid
//              [vt]         -- Datatype of property.  VT_VARIANT if unknown.
//              [cbMaxLen]   -- Soft-maximum length for variable length
//                              properties.  This much space is pre-allocated
//                              in original record.
//              [ulToken]    -- Token of transaction
//              [fCanBeModified]-- Can the prop meta info be modified once set?
//
//  History:    22-Oct-97         KrishnaN       Created.
//
//----------------------------------------------------------------------------

void CPropStoreManager::Setup( PROPID pid,
                            ULONG vt,
                            DWORD cbMaxLen,
                            ULONG_PTR ulToken,
                            BOOL fCanBeModified,
                            DWORD dwStoreLevel )
{
    if ( ulToken != (ULONG_PTR)_xpsNew.GetPointer() )
    {
        ciDebugOut(( DEB_ERROR, "Transaction mismatch: 0x%x vs. 0x%x\n", ulToken, _xpsNew.GetPointer() ));
        THROW( CException( STATUS_TRANSACTION_NO_MATCH ) );
    }

    //
    // Currently we only allow operations on one store during a transaction.
    // Remember that or enforce that, as appropriate.
    //

    if (INVALID_STORE_LEVEL == _dwXctionStoreLevel)
        _dwXctionStoreLevel = dwStoreLevel;
    else
    {
        Win4Assert(PRIMARY_STORE == dwStoreLevel || SECONDARY_STORE == dwStoreLevel);

        // should be primary or secondary
        if (PRIMARY_STORE != dwStoreLevel && SECONDARY_STORE != dwStoreLevel)
        {
            THROW( CException( STATUS_TRANSACTION_INVALID_TYPE ) );
        }

        // should be the same as the first store used in the transaction
        if (_dwXctionStoreLevel != dwStoreLevel)
        {
            THROW( CException( STATUS_TRANSACTION_NO_MATCH ) );
        }
    }

    // Before placing the pid in a store, assert that it doesn't
    // exist in the other store.

    CLock lock( _mtxWrite );

    CPropStoreManager *pStoreMgr = (CPropStoreManager *)ulToken;

    if (PRIMARY_STORE == dwStoreLevel)
    {
        Win4Assert(_xSecondaryStore->CanStore(pid) == FALSE);

        if (_xSecondaryStore->CanStore(pid))
        {
            THROW( CException( STATUS_TRANSACTION_NO_MATCH ) );
        }

        _xPrimaryStore->Setup(pid, vt, cbMaxLen,
                              (ULONG_PTR)pStoreMgr->_xPrimaryStore.GetPointer(),
                              fCanBeModified);
    }
    else
    {
       Win4Assert(_xPrimaryStore->CanStore(pid) == FALSE);

       if (_xPrimaryStore->CanStore(pid))
       {
           THROW( CException( STATUS_TRANSACTION_NO_MATCH ) );
       }

       _xSecondaryStore->Setup(pid, vt, cbMaxLen,
                               (ULONG_PTR)pStoreMgr->_xSecondaryStore.GetPointer(),
                               fCanBeModified);
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::EndTransaction, public
//
//  Synopsis:   End property transaction, and maybe commit changes.
//
//  Arguments:  [ulToken] -- Token of transaction
//              [fCommit] -- TRUE --> Commit transaction
//              [pidFixedPrimary]   -- Every workid with this pid will move to the
//                                     same workid in the new property cache.
//              [pidFixedSecondary] -- Every workid with this pid will move to the
//                                     same workid in the new property cache.
//
//  History:    22-Oct-97     KrishnaN       Created.
//
//----------------------------------------------------------------------------

void CPropStoreManager::EndTransaction( ULONG_PTR ulToken, BOOL fCommit,
                                        PROPID pidFixedPrimary,
                                        PROPID pidFixedSecondary )
{
    Win4Assert(ulToken);

    CLock lock( _mtxWrite );

    if ( ulToken != (ULONG_PTR)_xpsNew.GetPointer() )
    {
        ciDebugOut(( DEB_ERROR,
                     "PropStMgr: Transaction mismatch: 0x%x vs. 0x%x\n",
                     ulToken, _xpsNew.GetPointer() ));
        THROW( CException( STATUS_TRANSACTION_NO_MATCH ) );
    }

    _xPrimaryStore->EndTransaction((ULONG_PTR)_xpsNew->_xPrimaryStore.GetPointer(),
                                   fCommit, pidFixedPrimary);
    _xSecondaryStore->EndTransaction((ULONG_PTR)_xpsNew->_xSecondaryStore.GetPointer(),
                                     fCommit, pidFixedSecondary);

    // The primary and secondary ptrs are already deleted in EndTransaction
    // calls. Cleanup to reflect them prior to deleting _xpsNew.

    _xpsNew->_xPrimaryStore.Acquire();
    _xpsNew->_xSecondaryStore.Acquire();

    _xpsNew.Free();
} //EndTransaction

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::MakeBackupCopy
//
//  Synopsis:   Makes a backup copy of the property storage. It makes a
//              full copy if the pIEnumWorkids is NULL. Otherwise, it makes
//              a copy of only the changed workids.
//
//  Arguments:  [pIProgressEnum] - Progress indication
//              [pfAbort]        - Caller initiated abort flag
//              [dstStorage]     - Destination storage to use
//              [pIEnumWorkids]  - List of workids to copy. If null, all the
//              workids are copied.
//              [ppFileList]     - List of propstore files copied.
//
//  History:    22-Oct-97    KrishnaN   Created
//
//  Notes:      Incremental not implemented yet
//
//----------------------------------------------------------------------------


void CPropStoreManager::MakeBackupCopy( IProgressNotify * pIProgressEnum,
                                     BOOL & fAbort,
                                     CiStorage & dstStorage,
                                     ICiEnumWorkids * pIEnumWorkids,
                                     IEnumString **ppFileList )
{
    CLock lock( _mtxWrite );

    Flush();

    // fill in an array of sizes to pass into CCompositeProgressNotifier
    DWORD *pdwStoreSizes = new DWORD[2];
    pdwStoreSizes[0] = _xPrimaryStore->GetTotalSizeInKB();
    pdwStoreSizes[1] = _xSecondaryStore->GetTotalSizeInKB();

    CCompositeProgressNotifier ProgressNotifier( pIProgressEnum, pdwStoreSizes );

    _xPrimaryStore->MakeBackupCopy(&ProgressNotifier, fAbort, dstStorage,
                                   pIEnumWorkids, ppFileList);
    ProgressNotifier.IncrementFinishedComponents();

    ICiEnumWorkids *pIEnumSecondaryWorkids = pIEnumWorkids;

    _xSecondaryStore->MakeBackupCopy(&ProgressNotifier, fAbort, dstStorage,
                                     pIEnumSecondaryWorkids, ppFileList);
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::WriteProperty, public
//
//  Synopsis:   Write a property to the cache.
//
//  Arguments:  [wid] -- Workid
//              [pid] -- Propid
//              [var] -- Value
//
//  Returns:    Scode propagated from underlying store.
//
//  History:    24-Oct-97      KrishnaN       Created.
//
//----------------------------------------------------------------------------

SCODE CPropStoreManager::WriteProperty( WORKID wid,
                                        PROPID pid,
                                        CStorageVariant const & var )
{
    if ( _xPrimaryStore->CanStore( pid ) )
    {
        return WritePrimaryProperty( wid, pid, var );
    }
    else
    {
        CCompositePropRecordForWrites PropRecord( wid, *this, _mtxWrite );

        return _xSecondaryStore->WriteProperty( PropRecord.GetSecondaryPropRecord(),
                                                pid,
                                                var,
                                                IsBackedUpMode() );
    }
} //WriteProperty

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::WriteProperty, public
//
//  Synopsis:   Write a property to the specified cache.
//
//  Arguments:  [dwStoreLevle] -- level of the property store to write to 
//              [PropRecord]   -- Previously opened property record.
//              [pid]          -- Propid
//              [var]          -- Value
//
//  Returns:    SCODE propagated from underlying store.
//
//  History:    23-Oct-2000      KitmanH       Created.
//
//----------------------------------------------------------------------------

SCODE CPropStoreManager::WriteProperty( DWORD dwStoreLevel,
                                        CCompositePropRecordForWrites & PropRecord,
                                        PROPID pid,
                                        CStorageVariant const & var )
{
    Win4Assert( PRIMARY_STORE == dwStoreLevel || SECONDARY_STORE == dwStoreLevel );
    
    if ( PRIMARY_STORE == dwStoreLevel )
    {
        if ( _xPrimaryStore->CanStore( pid ) )
            return WritePrimaryProperty( PropRecord, pid, var );
    }
    else
    {
        if ( _xSecondaryStore->CanStore( pid ) )
            return WriteSecondaryProperty( PropRecord, pid, var );
    }

    return E_INVALIDARG;
    
} //WriteProperty

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::WritePrimaryProperty, public
//
//  Synopsis:   Write a property from the cache.  Triggers CoTaskMemAlloc
//
//  Arguments:  [wid] -- Workid
//              [pid] -- Propid
//              [var] -- Place to return the value
//
//  History:    22-Oct-97   KrishnaN       Created.
//
//----------------------------------------------------------------------------

SCODE CPropStoreManager::WritePrimaryProperty( WORKID wid,
                                               PROPID pid,
                                               CStorageVariant const & var )
{
    CPrimaryPropRecordForWrites PropRecord( wid, *this, _mtxWrite );

    return WritePrimaryProperty( PropRecord, pid, var );
}


//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::WriteProperty, public
//
//  Synopsis:   Write a property to the cache.
//
//  Arguments:  [PropRecord] -- Previously opened property record.
//              [pid] -- Propid
//              [var] -- Value
//
//  Returns:    Scode propagated from underlying store.
//
//  History:    24-Oct-97      KrishnaN       Created.
//
//----------------------------------------------------------------------------

SCODE CPropStoreManager::WriteProperty( CCompositePropRecordForWrites & PropRecord,
                                        PROPID pid, CStorageVariant const & var )
{
    ciDebugOut(( DEB_PROPSTORE, "WRITE: proprecord = 0x%x, pid = 0x%x, type = %d\n", &PropRecord, pid, var.Type() ));

    if (_xPrimaryStore->CanStore(pid))
        return _xPrimaryStore->WriteProperty(PropRecord.GetPrimaryPropRecord(), pid, var, IsBackedUpMode() );
    else
        return _xSecondaryStore->WriteProperty(PropRecord.GetSecondaryPropRecord(), pid, var, IsBackedUpMode() );
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::WritePrimaryProperty, public
//
//  Synopsis:   Write a property from the cache.  Triggers CoTaskMemAlloc
//
//  Arguments:  [PropRecord] -- Previously opened property record
//              [pid] -- Propid
//              [var] -- Place to return the value
//
//  History:    17-Mar-98   KrishnaN       Created.
//
//----------------------------------------------------------------------------

SCODE CPropStoreManager::WritePrimaryProperty( CCompositePropRecordForWrites & PropRecord,
                                               PROPID pid, CStorageVariant const & var )
{
    // Has to be used only to Write pids in the primary store.
    Win4Assert(_xPrimaryStore->CanStore(pid) == TRUE);

    return _xPrimaryStore->WriteProperty( PropRecord.GetPrimaryPropRecord(), pid, var, IsBackedUpMode() );
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::WritePrimaryProperty, public
//
//  Synopsis:   Write a property from the cache.  Triggers CoTaskMemAlloc
//
//  Arguments:  [PropRecord] -- Previously opened property record
//              [pid] -- Propid
//              [var] -- Place to return the value
//
//  History:    17-Mar-98   KrishnaN       Created.
//
//----------------------------------------------------------------------------

SCODE CPropStoreManager::WritePrimaryProperty( CPrimaryPropRecordForWrites & PropRecord,
                                               PROPID pid,
                                               CStorageVariant const & var )
{
    // Has to be used only to Write pids in the primary store.
    Win4Assert(_xPrimaryStore->CanStore(pid) == TRUE);

    return _xPrimaryStore->WriteProperty( PropRecord.GetPrimaryPropRecord(), pid, var, IsBackedUpMode() );
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::WriteSecondaryProperty, public
//
//  Synopsis:   Write a property from the cache. Triggers CoTaskMemAlloc
//
//  Arguments:  [PropRecord] -- Previously opened property record
//              [pid] -- Propid
//              [var] -- Place to return the value
//
//  History:    23-Oct-2000   KitmanH       Created.
//
//----------------------------------------------------------------------------

SCODE CPropStoreManager::WriteSecondaryProperty( CCompositePropRecordForWrites & PropRecord,
                                                 PROPID pid, CStorageVariant const & var )
{
    Win4Assert(_xSecondaryStore->CanStore(pid) == TRUE);

    return _xSecondaryStore->WriteProperty( PropRecord.GetSecondaryPropRecord(), pid, var, IsBackedUpMode() );
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::ReadProperty, public
//
//  Synopsis:   Read a property from the cache.
//
//  Arguments:  [wid]    -- Workid
//              [pid]    -- Propid
//              [pbData] -- Place to return the value
//              [pcb]    -- On input, the maximum number of bytes to
//                          write at pbData.  On output, the number of
//                          bytes written if the call was successful,
//                          else the number of bytes required.
//
//  History:    22-Oct-97     KrishnaN       Created.
//
//----------------------------------------------------------------------------

BOOL CPropStoreManager::ReadProperty( WORKID wid, PROPID pid,
                                      PROPVARIANT * pbData, unsigned * pcb )
{
    unsigned cb = *pcb - sizeof (PROPVARIANT);
    BOOL fOk = ReadProperty( wid, pid, *pbData, (BYTE *)(pbData + 1), &cb );
    *pcb = cb + sizeof (PROPVARIANT);

    return fOk;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::ReadProperty, public
//
//  Synopsis:   Read a property from the cache.  Version which uses property
//              record.
//
//  Arguments:  [PropRec] -- Pre-opened property record
//              [pid]     -- Propid
//              [pbData]  -- Place to return the value
//              [pcb]     -- On input, the maximum number of bytes to
//                           write at pbData.  On output, the number of
//                           bytes written if the call was successful,
//                           else the number of bytes required.
//
//  History:    22-Oct-97   KrishnaN       Created.
//
//----------------------------------------------------------------------------

BOOL CPropStoreManager::ReadProperty( CCompositePropRecord & PropRec,
                                      PROPID pid,
                                      PROPVARIANT * pbData,
                                      unsigned * pcb )
{
    unsigned cb = *pcb - sizeof (PROPVARIANT);
    BOOL fOk = ReadProperty( PropRec, pid, *pbData, (BYTE *)(pbData + 1), &cb );
    *pcb = cb + sizeof (PROPVARIANT);

    return fOk;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::ReadProperty, public
//
//  Synopsis:   Read a property from the cache.  Version which uses property
//              record.
//
//  Arguments:  [PropRec] -- Pre-opened property record
//              [pid]     -- Propid
//              [var] -- Place to return the value
//
//  History:    19-Dec-97   dlee      Created.
//
//----------------------------------------------------------------------------

BOOL CPropStoreManager::ReadProperty(
    CCompositePropRecord & PropRec,
    PROPID                 pid,
    PROPVARIANT &          var )
{
    unsigned cb = 0xFFFFFFFF;
    return ReadProperty( PropRec, pid, var, 0, &cb );
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::ReadProperty, public
//
//  Synopsis:   Read a property from the cache.  Version which uses property
//              record.
//
//  Arguments:  [PropRec] -- Pre-opened property record
//              [pid]     -- Propid
//              [var] -- Place to return the value
//
//  History:    19-Dec-97   dlee      Created.
//
//----------------------------------------------------------------------------

BOOL CPropStoreManager::ReadProperty(
    CPrimaryPropRecord & PropRec,
    PROPID               pid,
    PROPVARIANT &        var )
{
    unsigned cb = 0xFFFFFFFF;
    return ReadProperty( PropRec, pid, var, 0, &cb );
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::ReadProperty, public
//
//  Synopsis:   Read a property from the cache.  Triggers CoTaskMemAlloc
//
//  Arguments:  [wid] -- Workid
//              [pid] -- Propid
//              [var] -- Place to return the value
//
//  History:    22-Oct-97   KrishnaN       Created.
//
//----------------------------------------------------------------------------

BOOL CPropStoreManager::ReadProperty(
    WORKID        wid,
    PROPID        pid,
    PROPVARIANT & var )
{
    unsigned cb = 0xFFFFFFFF;
    return ReadProperty( wid, pid, var, 0, &cb );
}


//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::ReadProperty, public
//
//  Synopsis:   Read a property from the cache.  Triggers CoTaskMemAlloc
//
//  Arguments:  [wid] -- Workid
//              [pid] -- Propid
//              [var] -- Place to return the value
//
//  History:    22-Oct-97   KrishnaN       Created.
//
//----------------------------------------------------------------------------

BOOL CPropStoreManager::ReadPrimaryProperty( WORKID wid, PROPID pid, PROPVARIANT & var )
{
    // Has to be used only to read pids in the primary store.
    Win4Assert(_xPrimaryStore->CanStore(pid) == TRUE);

    unsigned cb = 0xFFFFFFFF;
    BOOL fOk = _xPrimaryStore->ReadProperty( wid, pid, var, 0, &cb );

    return fOk;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::ReadProperty, public
//
//  Synopsis:   Read a property from the cache.  Separate variable buffer.
//
//  Arguments:  [wid]      -- Workid
//              [pid]      -- Propid
//              [var]      -- Variant written here
//              [pbExtra]  -- Place to store additional pointer(s).
//              [pcbExtra] -- On input, the maximum number of bytes to
//                            write at pbExtra.  On output, the number of
//                            bytes written if the call was successful,
//                            else the number of bytes required.
//
//  History:    24-Oct-97      KrishnaN       Created.
//
//----------------------------------------------------------------------------

BOOL CPropStoreManager::ReadProperty( WORKID wid,
                                      PROPID pid,
                                      PROPVARIANT & var,
                                      BYTE * pbExtra,
                                      unsigned * pcbExtra )
{
    if ( _xPrimaryStore->CanStore( pid ) )
    {
        CPrimaryPropRecord PropRecord( wid, *this );
        return ReadProperty( PropRecord, pid, var, pbExtra, pcbExtra );
    }
    else
    {
        // the constructor seeds the constituent proprecords
        // with the right wid, based on the wid we pass in.

        CCompositePropRecord PropRecord( wid, *this );

        return _xSecondaryStore->ReadProperty( PropRecord.GetSecondaryPropRecord(),
                                              pid, var, pbExtra, pcbExtra);
    }
} //ReadProperty

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::ReadProperty, public
//
//  Synopsis:   Read a property from the cache.  Separate variable buffer.
//              Uses pre-opened property record.
//
//  Arguments:  [PropRec]  -- Pre-opened property record.
//              [pid]      -- Propid
//              [var]      -- Variant written here
//              [pbExtra]  -- Place to store additional pointer(s).
//              [pcbExtra] -- On input, the maximum number of bytes to
//                            write at pbExtra.  On output, the number of
//                            bytes written if the call was successful,
//                            else the number of bytes required.
//
//  History:    03-Apr-96   KyleP       Created.
//
//----------------------------------------------------------------------------

BOOL CPropStoreManager::ReadProperty( CCompositePropRecord & PropRecord,
                                   PROPID pid,
                                   PROPVARIANT & var,
                                   BYTE * pbExtra,
                                   unsigned * pcbExtra )
{
    if (_xPrimaryStore->CanStore(pid))
    {
        return _xPrimaryStore->ReadProperty(PropRecord.GetPrimaryPropRecord(),
                                            pid, var, pbExtra, pcbExtra);
    }
    else
    {
        return _xSecondaryStore->ReadProperty(PropRecord.GetSecondaryPropRecord(),
                                              pid, var, pbExtra, pcbExtra);
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::ReadProperty, public
//
//  Synopsis:   Read a property from the cache.  Separate variable buffer.
//              Uses pre-opened property record.
//
//  Arguments:  [PropRec]  -- Pre-opened property record.
//              [pid]      -- Propid
//              [var]      -- Variant written here
//              [pbExtra]  -- Place to store additional pointer(s).
//              [pcbExtra] -- On input, the maximum number of bytes to
//                            write at pbExtra.  On output, the number of
//                            bytes written if the call was successful,
//                            else the number of bytes required.
//
//  History:    03-Apr-96   KyleP       Created.
//
//----------------------------------------------------------------------------

BOOL CPropStoreManager::ReadProperty( CPrimaryPropRecord & PropRecord,
                                      PROPID pid,
                                      PROPVARIANT & var,
                                      BYTE * pbExtra,
                                      unsigned * pcbExtra )
{
    Win4Assert( _xPrimaryStore->CanStore(pid) );
    return _xPrimaryStore->ReadProperty(PropRecord.GetPrimaryPropRecord(),
                                        pid, var, pbExtra, pcbExtra);
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::OpenRecord, public
//
//  Synopsis:   Opens record (for multiple reads)
//
//  Arguments:  [wid] -- Workid
//              [pb]  -- Storage for record
//
//  Returns:    Pointer to open property record.  Owned by caller.
//
//  History:    03-Apr-96   KyleP       Created.
//
//----------------------------------------------------------------------------

CCompositePropRecord * CPropStoreManager::OpenRecord( WORKID wid, BYTE * pb )
{
    Win4Assert( sizeof(CCompositePropRecord) <= sizeof_CCompositePropRecord );
    return new( pb ) CCompositePropRecord( wid, *this );
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::CloseRecord, public
//
//  Synopsis:   Closes record.
//
//  Arguments:  [pRec] -- Property record
//
//  History:    03-Apr-96   KyleP       Created.
//
//----------------------------------------------------------------------------

void CPropStoreManager::CloseRecord( CCompositePropRecord * pRec )
{
    delete pRec;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::OpenPrimaryRecord, public
//
//  Synopsis:   Opens record (for multiple reads)
//
//  Arguments:  [wid] -- Workid
//              [pb]  -- Storage for record
//
//  Returns:    Pointer to open property record.  Owned by caller.
//
//  History:    03-Apr-96   KyleP       Created.
//
//----------------------------------------------------------------------------

CPrimaryPropRecord * CPropStoreManager::OpenPrimaryRecord( WORKID wid, BYTE * pb )
{
    Win4Assert( sizeof(CPrimaryPropRecord) <= sizeof_CPropRecord );
    return new( pb ) CPrimaryPropRecord( wid, *this );
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::CloseRecord, public
//
//  Synopsis:   Closes record.
//
//  Arguments:  [pRec] -- Property record
//
//  History:    03-Apr-96   KyleP       Created.
//
//----------------------------------------------------------------------------

void CPropStoreManager::CloseRecord( CPrimaryPropRecord * pRec )
{
    delete pRec;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::OpenRecordForWrites, public
//
//  Synopsis:   Opens record (for multiple writes)
//
//  Arguments:  [wid] -- Workid
//              [pb]  -- Storage for record
//
//  Returns:    Pointer to open property record.  Owned by caller.
//
//  History:    17-Mar-98   KrishnaN       Created.
//
//----------------------------------------------------------------------------

CCompositePropRecordForWrites * CPropStoreManager::OpenRecordForWrites( WORKID wid, BYTE * pb )
{
    Win4Assert( sizeof(CCompositePropRecordForWrites) <= sizeof_CCompositePropRecord );
    return new( pb ) CCompositePropRecordForWrites( wid, *this, _mtxWrite );
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::OpenPrimaryRecordForWrites, public
//
//  Synopsis:   Opens record (for multiple writes)
//
//  Arguments:  [wid] -- Workid
//              [pb]  -- Storage for record
//
//  Returns:    Pointer to open property record.  Owned by caller.
//
//  History:    17-Mar-98   KrishnaN       Created.
//
//----------------------------------------------------------------------------

CPrimaryPropRecordForWrites * CPropStoreManager::OpenPrimaryRecordForWrites( WORKID wid, BYTE * pb )
{
    Win4Assert( sizeof(CPrimaryPropRecordForWrites) <= sizeof_CPropRecord );
    return new( pb ) CPrimaryPropRecordForWrites( wid, *this, _mtxWrite );
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::CloseRecord, public
//
//  Synopsis:   Closes record.
//
//  Arguments:  [pRec] -- Property record
//
//  History:    17-Mar-98   KrishnaN       Created.
//
//----------------------------------------------------------------------------

void CPropStoreManager::CloseRecord( CCompositePropRecordForWrites * pRec )
{
    delete pRec;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::CloseRecord, public
//
//  Synopsis:   Closes record.
//
//  Arguments:  [pRec] -- Property record
//
//  History:    17-Mar-98   KrishnaN       Created.
//
//----------------------------------------------------------------------------

void CPropStoreManager::CloseRecord( CPrimaryPropRecordForWrites * pRec )
{
    delete pRec;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::DeleteRecord, public
//
//  Synopsis:   Free a record and any records chained off it.
//
//  Arguments:  [wid] -- Workid
//
//  History:    24-Oct-97      KrishnaN       Created.
//
//----------------------------------------------------------------------------

void CPropStoreManager::DeleteRecord( WORKID wid )
{
    CLock   lock( _mtxWrite );

    ciDebugOut(( DEB_PROPSTORE, "DELETE: wid = 0x%x\n", wid ));

    //
    // Get the secondary store's top-level wid before getting rid
    // of the wid in the primary store.
    //

    //
    // The secondary wid can certainly be bogus if we couldn't write
    // it to the primary store after allocating it when creating the
    // records.
    //

    WORKID widSec = GetSecondaryTopLevelWid(wid);

    if ( widInvalid != widSec && 0 != widSec )
        _xSecondaryStore->DeleteRecord( widSec,
                                        IsBackedUpMode() );

    _xPrimaryStore->DeleteRecord( wid, IsBackedUpMode() );
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::Flush
//
//  Synopsis:   Flushes the data in the property store and marks it clean.
//
//  History:    3-20-96   srikants   Created
//
//----------------------------------------------------------------------------

void CPropStoreManager::Flush()
{
    CLock mtxLock( _mtxWrite );

    // Flush both the stores. Only when both are successful
    // do we consider the entire flush to be successful.
    // Don't reset the backup streams until the flush is
    // completely successful.

    BOOL fFlushOK = _xPrimaryStore->Flush();
    if (fFlushOK)
        fFlushOK = _xSecondaryStore->Flush();

    // Reset the primary and the secondary backup stores
    if (fFlushOK)
    {
        if (_xPrimaryStore->BackupStream())
            _xPrimaryStore->BackupStream()->Reset(_xPrimaryStore->GetDesiredBackupSize());

        if (_xSecondaryStore->BackupStream())
            _xSecondaryStore->BackupStream()->Reset(_xSecondaryStore->GetDesiredBackupSize());
    }
}


//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::WritePropertyInNewRecord, public
//
//  Synopsis:   Like WriteProperty, but also allocates record.
//
//  Arguments:  [pid] -- Propid to write.
//              [var] -- Property value
//
//  Returns:    Workid of new record.
//
//  History:    22-Oct-97   KrishnaN       Created.
//
//----------------------------------------------------------------------------

WORKID CPropStoreManager::WritePropertyInNewRecord( PROPID pid,
                                                    CStorageVariant const & var )
{
    CLock lock( _mtxWrite );

    //
    // Get new wids from the primary and the secondary store.
    // Write the property.
    // Increment records in use for both the stores.
    //

    WORKID widPrimary = widInvalid;
    WORKID widSecondary = widInvalid;

    TRY
    {
        widPrimary = _xPrimaryStore->NewWorkId( 1, IsBackedUpMode() );
        widSecondary = _xSecondaryStore->NewWorkId( 1, IsBackedUpMode() );
    }
    CATCH(CException, e)
    {
        // cleanup if widSecondary is invalid
        if (widInvalid == widSecondary && widInvalid != widPrimary)
            _xPrimaryStore->DeleteRecord( widPrimary, IsBackedUpMode() );

        // Let the caller do what it normally does to handle exceptions
        RETHROW();
    }
    END_CATCH

    ciDebugOut(( DEB_PROPSTORE, "New record at primary: %d, secondary: %d\n",
                 widPrimary, widSecondary ));

    //
    // The primary's top-level record has a pointer to the
    // top-level record in the secondary store. Fill that now!
    //

    VARIANT newVar;
    newVar.vt = VT_UI4;
    newVar.ulVal = widSecondary;
    CStorageVariant *pVar = CastToStorageVariant(newVar);
    SCODE sc;

    sc = WritePrimaryProperty( widPrimary, pidSecondaryStorage, *pVar );
    if (FAILED(sc))
        THROW(CException(sc));

    sc = WriteProperty( widPrimary, pid, var );

    //
    // DLee add this assert to find out why this is failing sometimes.
    // Did the caller pass a bogus variant?
    //

    Win4Assert( HRESULT_FROM_WIN32( ERROR_INVALID_PARAMETER ) != sc );

    if (FAILED(sc))
        THROW(CException(sc));

    _xPrimaryStore->IncRecordsInUse();
    _xSecondaryStore->IncRecordsInUse();

    // To the outside world, the primary wid is the one that matters.
    return widPrimary;
}

//
// get and set parameters
// If incorrect parameter, default to the primary store.
//

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::SetBackupSize, public
//
//  Synopsis:   Sets backup size for a given property store.
//
//  Arguments:  [ulBackupSizeInPages] -- Size of the backup file.
//              [dwStoreLevel] -- Primary or secondary store?
//
//  History:    22-Oct-97   KrishnaN       Created.
//
//----------------------------------------------------------------------------

void CPropStoreManager::SetBackupSize(ULONG ulBackupSizeInPages,
                                      DWORD dwStoreLevel)
{
    if (SECONDARY_STORE == dwStoreLevel)
        _xSecondaryStore->SetBackupSize(ulBackupSizeInPages);
    else
    {
        Win4Assert(PRIMARY_STORE == dwStoreLevel);
        _xPrimaryStore->SetBackupSize(ulBackupSizeInPages);
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::GetBackupSize, public
//
//  Synopsis:   Gets backup size of a given property store.
//
//  Arguments:  [dwStoreLevel] -- Primary or secondary store?
//
//  History:    22-Oct-97   KrishnaN       Created.
//
//----------------------------------------------------------------------------

ULONG CPropStoreManager::GetBackupSize(DWORD dwStoreLevel)
{
    if ( SECONDARY_STORE == dwStoreLevel)
        return _xSecondaryStore->GetActualBackupSize();
    else
    {
        Win4Assert( PRIMARY_STORE == dwStoreLevel);
        return _xPrimaryStore->GetActualBackupSize();
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::SetMappedCacheSize, public
//
//  Synopsis:   Gets backup size of a given property store.
//
//  Arguments:  [dwStoreLevel] -- Primary or secondary store?
//
//  History:    22-Oct-97   KrishnaN       Created.
//
//----------------------------------------------------------------------------

void CPropStoreManager::SetMappedCacheSize(ULONG ulPSMappedCache,
                                               DWORD dwStoreLevel)
{
    if ( SECONDARY_STORE == dwStoreLevel)
        _xSecondaryStore->SetMappedCacheSize(ulPSMappedCache);
    else
    {
        Win4Assert( PRIMARY_STORE== dwStoreLevel);
        _xPrimaryStore->SetMappedCacheSize(ulPSMappedCache);
    }
}


//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::GetMappedCacheSize, public
//
//  Synopsis:   Gets mapped cache size of a given property store.
//
//  Arguments:  [dwStoreLevel] -- Primary or secondary store?
//
//  History:    22-Oct-97   KrishnaN       Created.
//
//----------------------------------------------------------------------------

ULONG CPropStoreManager::GetMappedCacheSize(DWORD dwStoreLevel)
{
    if (SECONDARY_STORE == dwStoreLevel)
        return _xSecondaryStore->GetMappedCacheSize();
    else
    {
        Win4Assert(PRIMARY_STORE == dwStoreLevel);
        return _xPrimaryStore->GetMappedCacheSize();
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CPropStoreManager::GetTotalSizeInKB, public
//
//  Synopsis:   Gets total size of the property store.
//
//  Arguments:
//
//  History:    22-Oct-97   KrishnaN       Created.
//
//----------------------------------------------------------------------------

ULONG CPropStoreManager::GetTotalSizeInKB()
{
    return _xPrimaryStore->GetTotalSizeInKB() +
           _xSecondaryStore->GetTotalSizeInKB();
}

PStorage& CPropStoreManager::GetStorage(DWORD dwStoreLevel)
{
    Win4Assert(&(_xPrimaryStore->GetStorage()) == _pStorage);
    Win4Assert(&(_xSecondaryStore->GetStorage()) == _pStorage);

    return *_pStorage;
}

void CPropStoreManager::Shutdown()
{
    Flush();
    _xPrimaryStore->Shutdown();
    _xSecondaryStore->Shutdown();
}

void CPropStoreManager::ClearNonStorageProperties( CCompositePropRecordForWrites & rec )
{
    _xPrimaryStore->ClearNonStorageProperties( rec );
    _xSecondaryStore->ClearNonStorageProperties( rec );
}

// CSvcQuery methods

//+-------------------------------------------------------------------------
//
//  Member:     CCompositeProgressNotifier::QueryInterface, public
//
//  Arguments:  [ifid]  -- Interface id
//              [ppiuk] -- Interface return pointer
//
//  Returns:    Error.  No rebind from this class is supported.
//
//  History:    Nov-14-97    KrishnaN     Created
//
//--------------------------------------------------------------------------

STDMETHODIMP CCompositeProgressNotifier::QueryInterface(
    REFIID  ifid,
    void ** ppiuk )
{
    if ( IID_IUnknown == ifid )
    {
        AddRef();
        *ppiuk = (void *)((IUnknown *)this);
        return S_OK;
    }
    else
    {
        *ppiuk = 0;
        return E_NOINTERFACE;
    }
} //QueryInterface

//+-------------------------------------------------------------------------
//
//  Member:     CCompositeProgressNotifier::AddRef, public
//
//  Synopsis:   Reference the virtual table.
//
//  History:    Nov-14-97    KrishnaN     Created
//
//--------------------------------------------------------------------------

STDMETHODIMP_(ULONG) CCompositeProgressNotifier::AddRef()
{
    InterlockedIncrement( &_ref );
    return (ULONG)_ref;
} //AddRef

//+-------------------------------------------------------------------------
//
//  Member:     CCompositeProgressNotifier::Release, public
//
//  Synopsis:   De-Reference the virtual table.
//
//  Effects:    If the ref count goes to 0 then the table is deleted.
//
//  History:    Nov-14-97    KrishnaN     Created
//
//--------------------------------------------------------------------------

STDMETHODIMP_(ULONG) CCompositeProgressNotifier::Release()
{
    unsigned long uTmp = InterlockedDecrement( &_ref );

    if ( 0 == uTmp )
        delete this;

    return(uTmp);
} //Release



//+-------------------------------------------------------------------------
//
//  Member:     CCompositeProgressNotifier::OnProgress, public
//
//  Synopsis:   Report progress.
//
//  Effects:    Progress reporting accounts for the presence of multiple
//              independently operating constituents in the property store.
//
//  History:    Nov-14-97    KrishnaN     Created
//
//--------------------------------------------------------------------------

STDMETHODIMP CCompositeProgressNotifier::OnProgress
                (
                 DWORD dwProgressCurrent,
                 DWORD dwProgressMaximum,
                 BOOL fAccurate,
                 BOOL fOwner
                )
{
    if (0 == _xComponentProgressNotifier.GetPointer())
        return S_OK;

    Win4Assert(_cFinishedComponents < _cComponents);
    Win4Assert(dwProgressMaximum == _aulMaxSizes[_cFinishedComponents]);

    //
    // Present a unified view of progress reports. The composite progress
    // report is 100% done only when all components are 100% done.
    //

    return _xComponentProgressNotifier->OnProgress
                 (dwProgressCurrent*1000/dwProgressMaximum + _dwCumMaxSize,
                  _dwTotalMaxSize,
                  fAccurate,
                  fOwner);

} //OnProgress