507 lines
13 KiB
C++
507 lines
13 KiB
C++
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1992.
|
|
//
|
|
// File: pbstream.hxx
|
|
//
|
|
// Contents: CPubStream definition
|
|
//
|
|
// Classes: CPubStream
|
|
//
|
|
// History: 16-Jan-92 PhilipLa Created.
|
|
// 12-Jun-96 MikeHill Moved the body of the FlushNoException
|
|
// method to the new Write method (except for
|
|
// the Commit). Made Flush & FlushNoException
|
|
// inline.
|
|
// 21-Jun-96 MikeHill Declare CPubMappedStream::_pb as based.
|
|
// 01-Jul-96 MikeHill - Adjust signatures for Win32 SEH removal.
|
|
// - Added _powner member to CPubMappedStream.
|
|
// 11-Feb-97 Danl - Make CPubMappedStream inherit from
|
|
// IMappedStream and stub IUnknowns.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
#ifndef __PBSTREAM_HXX__
|
|
#define __PBSTREAM_HXX__
|
|
|
|
#include <msf.hxx>
|
|
#include <revert.hxx>
|
|
#include <psstream.hxx>
|
|
#include <smalloc.hxx>
|
|
|
|
|
|
class CPubDocFile;
|
|
class CPubStream;
|
|
SAFE_DFBASED_PTR (CBasedPubStreamPtr, CPubStream);
|
|
SAFE_DFBASED_PTR (CBasedMappedStreamPtr, IMappedStream);
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Class: CPubMappedStream
|
|
//
|
|
// Purpose: Structure that lives in shared memory for
|
|
// mapped stream implementation.
|
|
//
|
|
// History: 1-May-95 BillMo Created.
|
|
//
|
|
// Notes:
|
|
//
|
|
//---------------------------------------------------------------
|
|
#ifdef NEWPROPS
|
|
class CPubMappedStream
|
|
{
|
|
|
|
public:
|
|
CPubMappedStream(CPubStream *pst)
|
|
{
|
|
_pb = NULL;
|
|
_cbUsed = 0;
|
|
_cbOriginalStreamSize = 0;
|
|
_fDirty = FALSE;
|
|
_fLowMem = FALSE;
|
|
_fChangePending = FALSE;
|
|
_pst = P_TO_BP(CBasedPubStreamPtr, pst);
|
|
_powner = NULL;
|
|
}
|
|
|
|
~CPubMappedStream()
|
|
{
|
|
msfAssert(_pb == NULL);
|
|
}
|
|
|
|
VOID Open(IN NTPROP np, OUT LONG *phr);
|
|
VOID Close(OUT LONG *phr);
|
|
VOID ReOpen(IN OUT VOID **ppv, OUT LONG *phr);
|
|
VOID Quiesce(VOID);
|
|
VOID Map(IN BOOLEAN fCreate, OUT VOID **ppv);
|
|
VOID Unmap(IN BOOLEAN fFlush, IN OUT VOID **ppv);
|
|
VOID Flush(OUT LONG *phr);
|
|
|
|
ULONG GetSize(OUT LONG *phr);
|
|
VOID SetSize(IN ULONG cb, IN BOOLEAN fPersistent, IN OUT VOID **ppv, OUT LONG *phr);
|
|
NTSTATUS Lock(IN BOOLEAN fExclusive);
|
|
NTSTATUS Unlock(VOID);
|
|
VOID QueryTimeStamps(OUT STATPROPSETSTG *pspss, BOOLEAN fNonSimple) const;
|
|
BOOLEAN QueryModifyTime(OUT LONGLONG *pll) const;
|
|
BOOLEAN QuerySecurity(OUT ULONG *pul) const;
|
|
|
|
BOOLEAN IsWriteable(VOID) const;
|
|
BOOLEAN IsModified(VOID) const;
|
|
VOID SetModified(OUT LONG *phr);
|
|
HANDLE GetHandle(VOID) const;
|
|
|
|
#if DBG
|
|
BOOLEAN SetChangePending(BOOLEAN fChangePending);
|
|
BOOLEAN IsNtMappedStream(VOID) const;
|
|
#endif
|
|
|
|
inline IMalloc * GetMalloc(VOID);
|
|
inline VOID Cleanup(VOID);
|
|
HRESULT Write ();
|
|
|
|
#if DBG
|
|
inline ULONG BytesCommitted(VOID) { return _cbUsed; }
|
|
VOID DfpdbgFillUnusedMemory(VOID);
|
|
VOID DfpdbgCheckUnusedMemory(VOID);
|
|
#else
|
|
VOID DfpdbgFillUnusedMemory(VOID) {}
|
|
VOID DfpdbgCheckUnusedMemory(VOID) {}
|
|
#endif
|
|
|
|
private:
|
|
|
|
CBasedPubStreamPtr _pst;
|
|
CBasedBytePtr _pb;
|
|
ULONG _cbUsed;
|
|
ULONG _cbOriginalStreamSize;
|
|
BOOLEAN _fDirty;
|
|
BOOLEAN _fLowMem;
|
|
BOOLEAN _fChangePending;
|
|
CBasedBytePtr _powner; // Owner of this mapped stream.
|
|
|
|
}; // class CPubMappedstream
|
|
#endif
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Class: CPubStream
|
|
//
|
|
// Purpose: Public stream interface
|
|
//
|
|
// Interface: See below
|
|
//
|
|
// History: 16-Jan-92 PhilipLa Created.
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
class CPubStream : public PRevertable
|
|
{
|
|
public:
|
|
|
|
CPubStream(CPubDocFile *ppdf,
|
|
DFLAGS df,
|
|
CDfName const *pdfn);
|
|
~CPubStream();
|
|
|
|
void Init(PSStream *psParent,
|
|
DFLUID dlLUID);
|
|
inline void vAddRef(void);
|
|
void vRelease(void);
|
|
|
|
// PRevertable
|
|
void RevertFromAbove(void);
|
|
#ifdef NEWPROPS
|
|
SCODE FlushBufferedData(int recursionlevel);
|
|
#endif
|
|
SCODE Stat(STATSTGW *pstatstg, DWORD grfStatFlag);
|
|
#ifdef LARGE_STREAMS
|
|
inline SCODE ReadAt(ULONGLONG ulOffset,
|
|
#else
|
|
inline SCODE ReadAt(ULONG ulOffset,
|
|
#endif
|
|
VOID *pb,
|
|
ULONG cb,
|
|
ULONG STACKBASED *pcbRead);
|
|
#ifdef LARGE_STREAMS
|
|
inline SCODE WriteAt(ULONGLONG ulOffset,
|
|
#else
|
|
inline SCODE WriteAt(ULONG ulOffset,
|
|
#endif
|
|
VOID const HUGEP *pb,
|
|
ULONG cb,
|
|
ULONG STACKBASED *pcbWritten);
|
|
#ifdef LARGE_STREAMS
|
|
inline SCODE GetSize(ULONGLONG *pcb);
|
|
inline SCODE SetSize(ULONGLONG cb);
|
|
#else
|
|
inline SCODE GetSize(ULONG *pcb);
|
|
inline SCODE SetSize(ULONG cb);
|
|
#endif
|
|
|
|
inline PSStream *GetSt(void) const;
|
|
#ifdef NEWPROPS
|
|
inline CPubMappedStream & GetMappedStream(void);
|
|
inline const CPubMappedStream & GetConstMappedStream(void);
|
|
#endif
|
|
inline SCODE CheckReverted(void) const;
|
|
inline ULONG GetTransactedDepth () const;
|
|
|
|
inline void SetClean(void);
|
|
inline void SetDirty(void);
|
|
|
|
SCODE Commit(DWORD dwFlags);
|
|
|
|
inline void EmptyCache ();
|
|
|
|
private:
|
|
CBasedSStreamPtr _psParent;
|
|
CBasedPubDocFilePtr _ppdfParent;
|
|
BOOL _fDirty;
|
|
LONG _cReferences;
|
|
#ifdef NEWPROPS
|
|
CPubMappedStream _PubMappedStream;
|
|
#endif
|
|
};
|
|
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CPubStream::CheckReverted, public
|
|
//
|
|
// Synopsis: Returns revertedness
|
|
//
|
|
// History: 11-Aug-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline SCODE CPubStream::CheckReverted(void) const
|
|
{
|
|
return P_REVERTED(_df) ? STG_E_REVERTED : S_OK;
|
|
}
|
|
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CPubStream::AddRef, public
|
|
//
|
|
// Synopsis: Increments the ref count
|
|
//
|
|
// History: 26-Feb-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline void CPubStream::vAddRef(void)
|
|
{
|
|
InterlockedIncrement(&_cReferences);
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CPubStream::GetSt, public
|
|
//
|
|
// Synopsis: Returns _psParent
|
|
//
|
|
// History: 26-Feb-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline PSStream *CPubStream::GetSt(void) const
|
|
{
|
|
return BP_TO_P(PSStream *, _psParent);
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CPubStream::GetMappedStream, public
|
|
//
|
|
// Synopsis: Returns this as a CPubMappedStream
|
|
//
|
|
// History: 26-May-95 BillMo Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
#ifdef NEWPROPS
|
|
inline CPubMappedStream & CPubStream::GetMappedStream(void)
|
|
{
|
|
return _PubMappedStream;
|
|
}
|
|
|
|
inline const CPubMappedStream & CPubStream::GetConstMappedStream(void)
|
|
{
|
|
return _PubMappedStream;
|
|
}
|
|
#endif
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CPubStream::SetClean, public
|
|
//
|
|
// Synopsis: Resets the dirty flag
|
|
//
|
|
// History: 11-Nov-92 DrewB Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void CPubStream::SetClean(void)
|
|
{
|
|
_fDirty = FALSE;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CPubStream::SetDirty, public
|
|
//
|
|
// Synopsis: Sets the dirty flag
|
|
//
|
|
// History: 11-Nov-92 DrewB Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void CPubStream::SetDirty(void)
|
|
{
|
|
_fDirty = TRUE;
|
|
_ppdfParent->SetDirty();
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Method: CPubStream::ReadAt, public
|
|
//
|
|
// Synopsis: Read from a stream
|
|
//
|
|
// Arguments: [ulOffset] - Byte offset to read from
|
|
// [pb] - Buffer
|
|
// [cb] - Count of bytes to read
|
|
// [pcbRead] - Return number of bytes actually read
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// Modifies: [pcbRead]
|
|
//
|
|
// History: 16-Jan-92 PhilipLa Created.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#ifdef LARGE_STREAMS
|
|
inline SCODE CPubStream::ReadAt(ULONGLONG ulOffset,
|
|
#else
|
|
inline SCODE CPubStream::ReadAt(ULONG ulOffset,
|
|
#endif
|
|
VOID *pb,
|
|
ULONG cb,
|
|
ULONG STACKBASED *pcbRead)
|
|
{
|
|
SCODE sc;
|
|
|
|
if (SUCCEEDED(sc = CheckReverted()))
|
|
if (!P_READ(_df))
|
|
sc = STG_E_ACCESSDENIED;
|
|
else
|
|
sc = _psParent->ReadAt(ulOffset,pb,cb,pcbRead);
|
|
return sc;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Method: CPubStream::WriteAt, public
|
|
//
|
|
// Synopsis: Write to a stream
|
|
//
|
|
// Arguments: [ulOffset] - Byte offset to write at
|
|
// [pb] - Buffer
|
|
// [cb] - Count of bytes to write
|
|
// [pcbWritten] - Return number of bytes actually written
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// Modifies: [pcbWritten]
|
|
//
|
|
// History: 16-Jan-92 PhilipLa Created.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#ifdef LARGE_STREAMS
|
|
inline SCODE CPubStream::WriteAt(ULONGLONG ulOffset,
|
|
#else
|
|
inline SCODE CPubStream::WriteAt(ULONG ulOffset,
|
|
#endif
|
|
VOID const HUGEP *pb,
|
|
ULONG cb,
|
|
ULONG STACKBASED *pcbWritten)
|
|
{
|
|
SCODE sc;
|
|
|
|
if (SUCCEEDED(sc = CheckReverted()))
|
|
if (!P_WRITE(_df))
|
|
sc = STG_E_ACCESSDENIED;
|
|
else
|
|
{
|
|
sc = _psParent->WriteAt(ulOffset,pb,cb,pcbWritten);
|
|
if (SUCCEEDED(sc))
|
|
SetDirty();
|
|
}
|
|
return sc;
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CPubStream::GetSize, public
|
|
//
|
|
// Synopsis: Gets the size of the stream
|
|
//
|
|
// Arguments: [pcb] - Stream size return
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// Modifies: [pcb]
|
|
//
|
|
// History: 30-Apr-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
#ifdef LARGE_STREAMS
|
|
inline SCODE CPubStream::GetSize(ULONGLONG *pcb)
|
|
#else
|
|
inline SCODE CPubStream::GetSize(ULONG *pcb)
|
|
#endif
|
|
{
|
|
SCODE sc;
|
|
|
|
if (SUCCEEDED(sc = CheckReverted()))
|
|
_psParent->GetSize(pcb);
|
|
return sc;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CPubStream::SetSize, public
|
|
//
|
|
// Synposis: Set the size of a linear stream
|
|
//
|
|
// Arguments: [ulNewSize] -- New size for stream
|
|
//
|
|
// Returns: Error code returned by MStream call.
|
|
//
|
|
// Algorithm: Pass call up to parent.
|
|
//
|
|
// History: 29-Jul-91 PhilipLa Created.
|
|
// 16-Jan-92 PhilipLa Moved from CSStream to CPubStream
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
#ifdef LARGE_STREAMS
|
|
inline SCODE CPubStream::SetSize(ULONGLONG ulNewSize)
|
|
#else
|
|
inline SCODE CPubStream::SetSize(ULONG ulNewSize)
|
|
#endif
|
|
{
|
|
SCODE sc;
|
|
|
|
if (SUCCEEDED(sc = CheckReverted()))
|
|
if (!P_WRITE(_df))
|
|
sc = STG_E_ACCESSDENIED;
|
|
else
|
|
{
|
|
sc = _psParent->SetSize(ulNewSize);
|
|
if (SUCCEEDED(sc))
|
|
SetDirty();
|
|
}
|
|
return sc;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CPubStream::EmptyCache, public
|
|
//
|
|
// Synposis: empties the stream cache for compaction
|
|
//
|
|
// History: 29-Jul-99 HenryLee Created.
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
inline void CPubStream::EmptyCache ()
|
|
{
|
|
_psParent->EmptyCache();
|
|
}
|
|
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CPubStream::GetTransactedDepth, public
|
|
//
|
|
// Synopsis: Returns transaction depth level from parent
|
|
//
|
|
// History: 11-Aug-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline ULONG CPubStream::GetTransactedDepth() const
|
|
{
|
|
return _ppdfParent->GetTransactedDepth();
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CPubMappedStream::GetMalloc, public
|
|
//
|
|
// Synposis: Get the allocator for the stream.
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
#ifdef NEWPROPS
|
|
inline IMalloc * CPubMappedStream::GetMalloc(void)
|
|
{
|
|
return &g_smAllocator;
|
|
}
|
|
|
|
inline VOID CPubMappedStream::Cleanup(VOID)
|
|
{
|
|
if (!_fLowMem)
|
|
GetMalloc()->Free(BP_TO_P(BYTE *, _pb));
|
|
_pb = NULL;
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif //__PBSTREAM_HXX__
|