839 lines
23 KiB
C++
839 lines
23 KiB
C++
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1993.
|
|
//
|
|
// File: propstg.hxx
|
|
//
|
|
// Contents: Class that directly implements IPropertyStorage
|
|
//
|
|
// Classes: CCoTaskAllocator
|
|
// CPropertyStorage
|
|
// CEnumSTATPROPSTG
|
|
//
|
|
// Functions:
|
|
//
|
|
//
|
|
//
|
|
// History: 1-Mar-95 BillMo Created.
|
|
// 25-Jan-96 MikeHill Added _fmtidSection.
|
|
// 22-May-96 MikeHill Added _dwOSVersion to CPropertyStorage.
|
|
// 06-Jun-96 MikeHill Added support for input validation.
|
|
// 18-Aug-96 MikeHill - Added CDocFilePropertyStorage.
|
|
//
|
|
// Notes:
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include <stgprops.hxx>
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Class: CCoTaskAllocator
|
|
//
|
|
// Purpose: Class used by RtlQueryProperties to allocate memory.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
class CCoTaskAllocator : public PMemoryAllocator
|
|
{
|
|
public:
|
|
virtual void *Allocate(ULONG cbSize);
|
|
virtual void Free(void *pv);
|
|
|
|
};
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Class: CPropertyStorage
|
|
//
|
|
// Purpose: Implements IPropertyStorage.
|
|
//
|
|
// Notes: This class uses the functionality provided by
|
|
// RtlCreatePropertySet, RtlSetProperties, RtlQueryProperties etc
|
|
// to manipulate the property set stream.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#define PROPERTYSTORAGE_SIG LONGSIG('P','R','P','S')
|
|
#define PROPERTYSTORAGE_SIGDEL LONGSIG('P','R','P','s')
|
|
#define PROPERTYSTORAGE_SIGZOMBIE LONGSIG('P','R','P','z')
|
|
#define ENUMSTATPROPSTG_SIG LONGSIG('E','P','S','S')
|
|
#define ENUMSTATPROPSTG_SIGDEL LONGSIG('E','P','S','s')
|
|
|
|
class CPropertyStorage : public IPropertyStorage
|
|
{
|
|
// ------------
|
|
// Constructors
|
|
// ------------
|
|
|
|
public:
|
|
|
|
// The destructor must be virtual so that derivative destructors
|
|
// will execute.
|
|
|
|
virtual ~CPropertyStorage();
|
|
|
|
CPropertyStorage()
|
|
{
|
|
Initialize();
|
|
}
|
|
|
|
// ---------------
|
|
// Exposed Methods
|
|
// ---------------
|
|
|
|
public:
|
|
|
|
virtual VOID Create(
|
|
IStream *stm,
|
|
REFFMTID rfmtid,
|
|
const CLSID *pclsid,
|
|
DWORD grfFlags,
|
|
HRESULT *phr);
|
|
|
|
virtual VOID Create(
|
|
IStorage *pstg,
|
|
REFFMTID rfmtid,
|
|
const CLSID *pclsid,
|
|
DWORD grfFlags,
|
|
HRESULT *phr);
|
|
|
|
virtual VOID Open(
|
|
IStorage *pstg,
|
|
REFFMTID rfmtid,
|
|
DWORD grfFlags,
|
|
HRESULT *phr);
|
|
virtual VOID Open(
|
|
IStream *pstm,
|
|
REFFMTID rfmtid,
|
|
DWORD grfFlags,
|
|
BOOL fDelete,
|
|
HRESULT *phr);
|
|
|
|
// IUnknown
|
|
STDMETHOD(QueryInterface)(REFIID riid, void **ppvObject);
|
|
|
|
STDMETHOD_(ULONG, AddRef)(void);
|
|
|
|
STDMETHOD_(ULONG, Release)(void);
|
|
|
|
// IPropertyStorage
|
|
STDMETHOD(ReadMultiple)(
|
|
ULONG cpspec,
|
|
const PROPSPEC rgpspec[],
|
|
PROPVARIANT rgpropvar[]);
|
|
|
|
STDMETHOD(WriteMultiple)(
|
|
ULONG cpspec,
|
|
const PROPSPEC rgpspec[],
|
|
const PROPVARIANT rgpropvar[],
|
|
PROPID propidNameFirst);
|
|
|
|
STDMETHOD(DeleteMultiple)(
|
|
ULONG cpspec,
|
|
const PROPSPEC rgpspec[]);
|
|
|
|
STDMETHOD(ReadPropertyNames)(
|
|
ULONG cpropid,
|
|
const PROPID rgpropid[],
|
|
LPOLESTR rglpwstrName[]);
|
|
|
|
STDMETHOD(WritePropertyNames)(
|
|
ULONG cpropid,
|
|
const PROPID rgpropid[],
|
|
const LPOLESTR rglpwstrName[]);
|
|
|
|
STDMETHOD(DeletePropertyNames)(
|
|
ULONG cpropid,
|
|
const PROPID rgpropid[]);
|
|
|
|
STDMETHOD(Commit)(DWORD grfCommitFlags);
|
|
|
|
STDMETHOD(Revert)();
|
|
|
|
STDMETHOD(Enum)(IEnumSTATPROPSTG ** ppenum);
|
|
|
|
STDMETHOD(SetTimes)(
|
|
FILETIME const * pctime,
|
|
FILETIME const * patime,
|
|
FILETIME const * pmtime);
|
|
|
|
STDMETHOD(SetClass)(REFCLSID clsid);
|
|
|
|
STDMETHOD(Stat)(STATPROPSETSTG * pstatpsstg);
|
|
|
|
// used by implementation helper classes
|
|
inline NTPROP GetNtPropSetHandle(void) { return _np; }
|
|
|
|
|
|
// ----------------
|
|
// Internal Methods
|
|
// ----------------
|
|
|
|
protected:
|
|
|
|
VOID Initialize();
|
|
HRESULT InitializeOnCreateOrOpen(
|
|
DWORD grfFlags,
|
|
DWORD grfMode,
|
|
REFFMTID rfmtid,
|
|
BOOL fCreate );
|
|
|
|
VOID CleanupOpenedObjects(
|
|
PROPVARIANT avar[],
|
|
INDIRECTPROPERTY * pip,
|
|
ULONG cpspec,
|
|
ULONG iFailIndex);
|
|
|
|
HRESULT InitializePropertyStream(
|
|
USHORT Flags,
|
|
const GUID * pguid,
|
|
GUID const * pclsid);
|
|
|
|
HRESULT _WriteMultiple(
|
|
ULONG cpspec,
|
|
const PROPSPEC rgpspec[],
|
|
const PROPVARIANT rgpropvar[],
|
|
PROPID propidNameFirst);
|
|
|
|
HRESULT _WritePropertyNames(
|
|
ULONG cpropid,
|
|
const PROPID rgpropid[],
|
|
const LPOLESTR rglpwstrName[]);
|
|
|
|
HRESULT HandleLowMemory();
|
|
|
|
HRESULT _CreateDocumentSummary2Stream(
|
|
IStorage * pstg,
|
|
CPropSetName & psn,
|
|
DWORD grfMode,
|
|
BOOL * fCreated);
|
|
|
|
virtual HRESULT CreateMappedStream( );
|
|
|
|
virtual VOID Lock(DWORD dwTimeout);
|
|
virtual VOID Unlock();
|
|
|
|
inline HRESULT Validate();
|
|
inline HRESULT ValidateRef();
|
|
|
|
inline HRESULT ValidateRGPROPSPEC( ULONG cpspec, const PROPSPEC rgpropspec[] );
|
|
inline HRESULT ValidateInRGPROPVARIANT( ULONG cpspec, const PROPVARIANT rgpropvar[] );
|
|
inline HRESULT ValidateOutRGPROPVARIANT( ULONG cpspec, PROPVARIANT rgpropvar[] );
|
|
inline HRESULT ValidateRGPROPID( ULONG cpropid, const PROPID rgpropid[] );
|
|
inline HRESULT ValidateInRGLPOLESTR( ULONG cpropid, const LPOLESTR rglpwstrName[] );
|
|
inline HRESULT ValidateOutRGLPOLESTR( ULONG cpropid, LPOLESTR rglpwstrName[] );
|
|
|
|
inline BOOL IsNonSimple();
|
|
inline BOOL IsSimple();
|
|
inline HRESULT IsWriteable();
|
|
inline HRESULT IsReadable();
|
|
inline DWORD GetCreationMode();
|
|
inline HRESULT IsReverted();
|
|
|
|
// -------------
|
|
// Internal Data
|
|
// -------------
|
|
|
|
protected:
|
|
|
|
ULONG _ulSig;
|
|
LONG _cRefs;
|
|
IStorage * _pstgPropSet;
|
|
IStream * _pstmPropSet;
|
|
NTPROP _np;
|
|
NTMAPPEDSTREAM _ms;
|
|
|
|
#ifndef _MAC
|
|
CRITICAL_SECTION _CriticalSection;
|
|
#endif
|
|
|
|
// We need to remember if the property set is the second section
|
|
// of the DocumentSummaryInformation property set used by Office. This
|
|
// is the only case where we support a multiple-section property set, and
|
|
// requires special handling in ::Revert().
|
|
|
|
BOOL _fUserDefinedProperties;
|
|
|
|
USHORT _usCodePage; // Ansi Codepage or Mac Script
|
|
// (disambiguate with _dwOSVersion)
|
|
ULONG _dwOSVersion; // Shows the OS Kind, major/minor version
|
|
|
|
|
|
DWORD _grfFlags; // PROPSETFLAG_NONSIMPLE and PROPSETFLAG_ANSI
|
|
DWORD _grfAccess; // grfMode & 3
|
|
DWORD _grfShare; // grfMode & 0xF0
|
|
|
|
// The following is a PMemoryAllocator for the Rtl property
|
|
// set routines. This instantiation was formerly a file-global
|
|
// in propstg.cxx. Howevewr, on the Mac, the object was not
|
|
// being instantiated.
|
|
|
|
CCoTaskAllocator _cCoTaskAllocator;
|
|
|
|
};
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CPropertyStorage::Validate
|
|
//
|
|
// Synopsis: S_OK if signature valid and not zombie.
|
|
//
|
|
// Notes: If the Revert calls fails due to low memory, then
|
|
// the object becomes a zombie.
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
inline HRESULT CPropertyStorage::Validate()
|
|
{
|
|
if (_ulSig == PROPERTYSTORAGE_SIG)
|
|
return S_OK;
|
|
else
|
|
if (_ulSig == PROPERTYSTORAGE_SIGZOMBIE)
|
|
return STG_E_INSUFFICIENTMEMORY;
|
|
else
|
|
return STG_E_INVALIDHANDLE;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CPropertyStorage::ValidateRef
|
|
//
|
|
// Synopsis: S_OK if signature valid.
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
inline HRESULT CPropertyStorage::ValidateRef()
|
|
{
|
|
if (_ulSig == PROPERTYSTORAGE_SIG || _ulSig == PROPERTYSTORAGE_SIGZOMBIE)
|
|
return(S_OK);
|
|
else
|
|
return(STG_E_INVALIDHANDLE);
|
|
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CPropertyStorage::ValidateRGPROPSPEC
|
|
//
|
|
// Synopsis: S_OK if PROPSPEC[] is valid
|
|
// E_INVALIDARG otherwise.
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
inline HRESULT CPropertyStorage::ValidateRGPROPSPEC( ULONG cpspec,
|
|
const PROPSPEC rgpropspec[] )
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
|
|
// Validate the array itself.
|
|
|
|
VDATESIZEREADPTRIN_LABEL(rgpropspec, cpspec * sizeof(PROPSPEC), errRet, hr);
|
|
|
|
// Validate the elements of the array.
|
|
|
|
for( ; cpspec > 0; cpspec-- )
|
|
{
|
|
// Is this an LPWSTR?
|
|
if( PRSPEC_LPWSTR == rgpropspec[cpspec-1].ulKind )
|
|
{
|
|
// We better at least be able to read the first
|
|
// character.
|
|
VDATEREADPTRIN_LABEL(rgpropspec[cpspec-1].lpwstr, WCHAR, errRet, hr);
|
|
}
|
|
|
|
// Otherwise, this better be a PROPID.
|
|
else if( PRSPEC_PROPID != rgpropspec[cpspec-1].ulKind )
|
|
{
|
|
goto errRet;
|
|
}
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
// ----
|
|
// Exit
|
|
// ----
|
|
|
|
errRet:
|
|
|
|
return( hr );
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CPropertyStorage::ValidateInRGPROPVARIANT
|
|
//
|
|
// Synopsis: S_OK if PROPVARIANT[] is valid for Read.
|
|
// E_INVALIDARG otherwise.
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
inline HRESULT CPropertyStorage::ValidateInRGPROPVARIANT( ULONG cpspec,
|
|
const PROPVARIANT rgpropvar[] )
|
|
{
|
|
// We verify that we can read the whole PropVariant[], but
|
|
// we don't validate the content of those elements.
|
|
|
|
HRESULT hr;
|
|
VDATESIZEREADPTRIN_LABEL(rgpropvar, cpspec * sizeof(PROPVARIANT), errRet, hr);
|
|
hr = S_OK;
|
|
|
|
errRet:
|
|
|
|
return( hr );
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CPropertyStorage::ValidateOutRGPROPVARIANT
|
|
//
|
|
// Synopsis: S_OK if PROPVARIANT[] is valid for Write.
|
|
// E_INVALIDARG otherwise.
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
inline HRESULT CPropertyStorage::ValidateOutRGPROPVARIANT( ULONG cpspec,
|
|
PROPVARIANT rgpropvar[] )
|
|
{
|
|
// We verify that we can write the whole PropVariant[], but
|
|
// we don't validate the content of those elements.
|
|
|
|
HRESULT hr;
|
|
VDATESIZEPTROUT_LABEL(rgpropvar, cpspec * sizeof(PROPVARIANT), errRet, hr);
|
|
hr = S_OK;
|
|
|
|
errRet:
|
|
|
|
return( hr );
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CPropertyStorage::ValidateRGPROPID
|
|
//
|
|
// Synopsis: S_OK if RGPROPID[] is valid for Read.
|
|
// E_INVALIDARG otherwise.
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
inline HRESULT CPropertyStorage::ValidateRGPROPID( ULONG cpropid,
|
|
const PROPID rgpropid[] )
|
|
{
|
|
HRESULT hr;
|
|
VDATESIZEREADPTRIN_LABEL( rgpropid, cpropid * sizeof(PROPID), errRet, hr );
|
|
hr = S_OK;
|
|
|
|
errRet:
|
|
|
|
return( hr );
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CPropertyStorage::ValidateOutRGLPOLESTR.
|
|
//
|
|
// Synopsis: S_OK if LPOLESTR[] is valid for Write.
|
|
// E_INVALIDARG otherwise.
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
inline HRESULT CPropertyStorage::ValidateOutRGLPOLESTR( ULONG cpropid,
|
|
LPOLESTR rglpwstrName[] )
|
|
{
|
|
HRESULT hr;
|
|
VDATESIZEPTROUT_LABEL( rglpwstrName, cpropid * sizeof(LPOLESTR), errRet, hr );
|
|
hr = S_OK;
|
|
|
|
errRet:
|
|
|
|
return( hr );
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CPropertyStorage::ValidateInRGLPOLESTR
|
|
//
|
|
// Synopsis: S_OK if LPOLESTR[] is valid for Read.
|
|
// E_INVALIDARG otherwise.
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
inline HRESULT CPropertyStorage::ValidateInRGLPOLESTR( ULONG cpropid,
|
|
const LPOLESTR rglpwstrName[] )
|
|
{
|
|
// Validate that we can read the entire vector.
|
|
|
|
HRESULT hr;
|
|
VDATESIZEREADPTRIN_LABEL( rglpwstrName, cpropid * sizeof(LPOLESTR), errRet, hr );
|
|
|
|
// Validate that we can at least read the first character of
|
|
// each of the strings.
|
|
|
|
for( ; cpropid > 0; cpropid-- )
|
|
{
|
|
VDATEREADPTRIN_LABEL( rglpwstrName[cpropid-1], WCHAR, errRet, hr );
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
errRet:
|
|
|
|
return( hr );
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CPropertyStorage::IsNonSimple
|
|
//
|
|
// Synopsis: true if non-simple
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
inline BOOL CPropertyStorage::IsNonSimple()
|
|
{
|
|
return (_grfFlags & PROPSETFLAG_NONSIMPLE) != 0;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CPropertyStorage::IsSimple
|
|
//
|
|
// Synopsis: true if simple
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
inline BOOL CPropertyStorage::IsSimple()
|
|
{
|
|
return !IsNonSimple();
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CPropertyStorage::IsWriteable
|
|
//
|
|
// Synopsis: S_OK if writeable otherwise STG_E_ACCESSDENIED
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
inline HRESULT CPropertyStorage::IsWriteable()
|
|
{
|
|
return (_grfAccess == STGM_WRITE || _grfAccess == STGM_READWRITE) ?
|
|
S_OK : STG_E_ACCESSDENIED;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CPropertyStorage::IsReadable
|
|
//
|
|
// Synopsis: S_OK if readable otherwise STG_E_ACCESSDENIED
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
inline HRESULT CPropertyStorage::IsReadable()
|
|
{
|
|
return (_grfAccess == STGM_READ || _grfAccess == STGM_READWRITE) ?
|
|
S_OK : STG_E_ACCESSDENIED;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CPropertyStorage::GetCreationMode
|
|
//
|
|
// Synopsis: Get grfMode for creating streams/storages for VT_STREAM etc
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
inline DWORD CPropertyStorage::GetCreationMode()
|
|
{
|
|
#ifndef _CAIRO_
|
|
const BOOL _fNative = FALSE;
|
|
#endif
|
|
return(STGM_DIRECT | STGM_CREATE |
|
|
(_fNative ? _grfShare : STGM_SHARE_EXCLUSIVE) | _grfAccess);
|
|
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CPropertyStorage::IsReverted
|
|
//
|
|
// Synopsis: S_OK if not reverted, STG_E_REVERTED otherwise.
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
inline HRESULT CPropertyStorage::IsReverted()
|
|
{
|
|
IUnknown *punk;
|
|
HRESULT hr = (IsNonSimple() ? (IUnknown*)_pstgPropSet : (IUnknown*)_pstmPropSet) ->
|
|
QueryInterface(IID_IUnknown, (void**)&punk);
|
|
|
|
// Normalize the result to either 'reverted' or 'OK'.
|
|
// Note: On older Mac implementations, memory-based streams will
|
|
// return E_NOINTERFACE here, due to a bug in the QueryInterface
|
|
// implementation.
|
|
|
|
if( STG_E_REVERTED != hr )
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
|
|
if( punk )
|
|
punk->Release();
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Class: CDocFilePropertyStorage
|
|
//
|
|
// Purpose: Implements a CPropertyStorage customized for
|
|
// use with IStorages & IStreams which are known
|
|
// to be DocFile (the OLE32 Compound File implementation).
|
|
//
|
|
// This derivation of CPropertyStorage takes advantage
|
|
// of the DocFile tree mutex, so that locking this
|
|
// object also locks the associated IStorage/IStream.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
class CDocFilePropertyStorage : public CPropertyStorage
|
|
{
|
|
|
|
public:
|
|
|
|
CDocFilePropertyStorage() {};
|
|
~CDocFilePropertyStorage()
|
|
{
|
|
// Prevent ~CPropertyStorage from attempting to delete
|
|
// the mapped stream, which in this case is actually
|
|
// a CExposedStream.
|
|
|
|
_ms = NULL;
|
|
}
|
|
|
|
// ----------------
|
|
// Public Overrides
|
|
// ----------------
|
|
|
|
// These methods are overridden to ensure that they are
|
|
// not used on a DocFile.
|
|
|
|
public:
|
|
|
|
VOID Create(
|
|
IStream *stm,
|
|
REFFMTID rfmtid,
|
|
const CLSID *pclsid,
|
|
DWORD grfFlags,
|
|
HRESULT *phr)
|
|
{
|
|
*phr = ERROR_CALL_NOT_IMPLEMENTED;
|
|
return;
|
|
}
|
|
|
|
VOID Create(
|
|
IStorage *pstg,
|
|
REFFMTID rfmtid,
|
|
const CLSID *pclsid,
|
|
DWORD grfFlags,
|
|
HRESULT *phr)
|
|
{
|
|
*phr = ERROR_CALL_NOT_IMPLEMENTED;
|
|
return;
|
|
}
|
|
|
|
VOID Open(
|
|
IStorage *pstg,
|
|
REFFMTID rfmtid,
|
|
DWORD grfFlags,
|
|
HRESULT *phr)
|
|
{
|
|
*phr = ERROR_CALL_NOT_IMPLEMENTED;
|
|
return;
|
|
}
|
|
VOID Open(
|
|
IStream *pstm,
|
|
REFFMTID rfmtid,
|
|
DWORD grfFlags,
|
|
BOOL fDelete,
|
|
HRESULT *phr)
|
|
{
|
|
*phr = ERROR_CALL_NOT_IMPLEMENTED;
|
|
return;
|
|
}
|
|
|
|
// ---------------
|
|
// Exposed Methods
|
|
// ---------------
|
|
|
|
public:
|
|
|
|
VOID Create(
|
|
IPrivateStorage * pprivstg,
|
|
REFFMTID rfmtid,
|
|
const CLSID * pclsid,
|
|
DWORD grfFlags,
|
|
DWORD grfMode,
|
|
HRESULT * phr);
|
|
|
|
VOID Open(
|
|
IPrivateStorage * pprivstg,
|
|
REFFMTID rfmtid,
|
|
DWORD grfMode,
|
|
BOOL fDelete,
|
|
HRESULT * phr);
|
|
|
|
|
|
// ------------------
|
|
// Internal Overrides
|
|
// ------------------
|
|
|
|
protected:
|
|
|
|
HRESULT CreateMappedStream( );
|
|
VOID Lock( DWORD dwTimeout );
|
|
VOID Unlock();
|
|
|
|
};
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Class: CStatArray
|
|
//
|
|
// Purpose: Class to allow sharing of enumeration STATPROPSTG state.
|
|
//
|
|
// Interface: CStatArray -- Enumerate entire NTPROP np.
|
|
// NextAt -- Perform an OLE-type Next operation starting at
|
|
// specified offset.
|
|
// AddRef -- for sharing of this by CEnumSTATPROPSTG
|
|
// Release -- ditto
|
|
//
|
|
// Notes: Each IEnumSTATPROPSTG instance has a reference to a
|
|
// CStatArray. When IEnumSTATPROPSTG::Clone is called, a
|
|
// new reference to the extant CStatArray is used: no copying.
|
|
//
|
|
// The CEnumSTATPROPSTG has a cursor into the CStatArray.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
class CStatArray
|
|
{
|
|
public:
|
|
CStatArray(NTPROP np, HRESULT *phr);
|
|
|
|
NTSTATUS NextAt(ULONG ipropNext, STATPROPSTG *pspsDest, ULONG *pceltFetched);
|
|
inline VOID AddRef();
|
|
inline VOID Release();
|
|
|
|
private:
|
|
~CStatArray();
|
|
|
|
LONG _cRefs;
|
|
|
|
STATPROPSTG * _psps;
|
|
ULONG _cpropActual;
|
|
};
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CStatArray::AddRef
|
|
//
|
|
// Synopsis: Increment ref count.
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
inline VOID CStatArray::AddRef()
|
|
{
|
|
InterlockedIncrement(&_cRefs);
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CStatArray::AddRef
|
|
//
|
|
// Synopsis: Decrement ref count and delete object if refs == 0.
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
inline VOID CStatArray::Release()
|
|
{
|
|
if (0 == InterlockedDecrement(&_cRefs))
|
|
delete this;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Class: CEnumSTATPROPSTG
|
|
//
|
|
// Purpose: Implement IEnumSTATPROPSTG
|
|
//
|
|
// Notes: Just holds a reference to a CStatArray that contains
|
|
// a static copy of the enumeration when the original
|
|
// Enum call was made. This object contains the cursor
|
|
// into the CStatArray.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
NTSTATUS CopySTATPROPSTG(ULONG celt,
|
|
STATPROPSTG * pspsDest,
|
|
const STATPROPSTG * pspsSrc);
|
|
|
|
VOID CleanupSTATPROPSTG(ULONG celt, STATPROPSTG * psps);
|
|
|
|
class CEnumSTATPROPSTG : public IEnumSTATPROPSTG
|
|
{
|
|
public:
|
|
CEnumSTATPROPSTG(NTPROP np, HRESULT *phr);
|
|
CEnumSTATPROPSTG(const CEnumSTATPROPSTG &other, HRESULT *phr);
|
|
|
|
~CEnumSTATPROPSTG();
|
|
|
|
STDMETHOD(QueryInterface)( REFIID riid, void **ppvObject);
|
|
|
|
STDMETHOD_(ULONG, AddRef)(void);
|
|
|
|
STDMETHOD_(ULONG, Release)(void);
|
|
|
|
STDMETHOD(Next)(ULONG celt,
|
|
STATPROPSTG * rgelt,
|
|
ULONG * pceltFetched);
|
|
|
|
// We don't need RemoteNext.
|
|
|
|
STDMETHOD(Skip)(ULONG celt);
|
|
|
|
STDMETHOD(Reset)();
|
|
|
|
STDMETHOD(Clone)(IEnumSTATPROPSTG ** ppenum);
|
|
|
|
private:
|
|
HRESULT Validate();
|
|
|
|
|
|
ULONG _ulSig;
|
|
LONG _cRefs;
|
|
|
|
CStatArray * _psa;
|
|
ULONG _ipropNext;
|
|
};
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CEnumSTATPROPSTG::Validate
|
|
//
|
|
// Synopsis: S_OK if signature is valid, otherwise error
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
inline HRESULT CEnumSTATPROPSTG::Validate()
|
|
{
|
|
return _ulSig == ENUMSTATPROPSTG_SIG ? S_OK : STG_E_INVALIDHANDLE;
|
|
}
|
|
|