|
|
//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1991 - 1996.
//
// File: msf.hxx
//
// Contents: Header for MSF for external use
//
// Classes: CMStream - Main multi-stream object
//
//--------------------------------------------------------------------------
#ifndef __MSF_HXX__
#define __MSF_HXX__
#include "ref.hxx"
#include "error.hxx"
#define SECURE
#define msfErr(l, e) ErrJmp(msf, l, e, sc)
#define msfChkTo(l, e) if (FAILED(sc = (e))) msfErr(l, sc) else 1
#define msfHChkTo(l, e) if (FAILED(sc = GetScode(e))) msfErr(l, sc) else 1
#define msfChk(e) msfChkTo(Err, e)
#define msfHChk(e) msfHChkTo(Err, e)
#define msfMemTo(l, e) if (!(e)) msfErr(l, STG_E_INSUFFICIENTMEMORY) else 1
#define msfMem(e) msfMemTo(Err, e)
#if DEVL == 1
DECLARE_DEBUG(msf);
#endif
#if DBG == 1
#define msfDebugOut(x) msfInlineDebugOut x
#include <assert.h>
#define msfAssert(e) assert(e)
#define msfVerify(e) assert(e)
#else
#define msfDebugOut(x)
#define msfAssert(e)
#define msfVerify(e) (e)
#endif
// MSF entry flags type
typedef DWORD MSENTRYFLAGS;
// MEF_ANY refers to all entries regardless of type
const MSENTRYFLAGS MEF_ANY = 255;
//CWCSTREAMNAME is the maximum length (in wide characters) of
// a stream name.
const USHORT CWCSTREAMNAME = 32;
//OFFSET and SECT are used to determine positions within
//a file.
typedef SHORT OFFSET;typedef ULONG SECT;
#define MAXINDEXTYPE ULONG
//FSINDEX and FSOFFSET are used to determine the position of a sector
//within the Fat.
typedef ULONG FSINDEX;typedef USHORT FSOFFSET;
// DIRINDEX and DIROFFSET and used to index directory tables
typedef ULONG DIRINDEX;typedef USHORT DIROFFSET;
//Size of a mini sector in bytes.
const USHORT MINISECTORSHIFT = 6;const USHORT MINISECTORSIZE = 1 << MINISECTORSHIFT; //64
//Maximum size of a ministream.
const USHORT MINISTREAMSIZE=4096;
//Size of a single sector in bytes.
const USHORT SECTORSHIFT = 9;const USHORT SECTORSIZE = 1 << SECTORSHIFT; //512
const USHORT MAXSECTORSHIFT = 16;
//Size of header.
const USHORT HEADERSIZE = SECTORSIZE;
//Size of single DirEntry
const USHORT DIRENTRYSIZE = SECTORSIZE / 4;
//
// Predefined Sector Indices
//
const SECT MAXREGSECT = 0xFFFFFFFB;const SECT DIFSECT=0xFFFFFFFC;const SECT FATSECT=0xFFFFFFFD;const SECT ENDOFCHAIN=0xFFFFFFFE;const SECT FREESECT=0xFFFFFFFF;
//Start of Fat chain
const SECT SECTFAT = 0;
//Start of directory chain
const SECT SECTDIR = 1;
class CDirectStream;class CMSFIterator;class CMSFPageTable;
class CStreamCache;
#define FLUSH_ILB TRUE
// ----------------------
// Byte swapping routines
// ----------------------
#include "../byteordr.hxx"
#include "dfmsp.hxx"
class CMStream;
#include "header.hxx"
#include "fat.hxx"
#include "dir.hxx"
#include "difat.hxx"
//
// Predefined Stream ID's
//
//Return code for Directory
//Used to signal a 'Stream Not Found' condition
const SID NOSTREAM=0xFFFFFFFF;
//Stream ID of FAT chain
const SID SIDFAT=0xFFFFFFFE;
//Stream ID of Directory chain
const SID SIDDIR=0xFFFFFFFD;
//SID for root level object
const SID SIDROOT = 0;
//SID of MiniFat
const SID SIDMINIFAT = 0xFFFFFFFC;
//SID of Double-indirect Fat
const SID SIDDIF = 0xFFFFFFFB;
//Stream ID for MiniStream chain
const SID SIDMINISTREAM = SIDROOT;
//SID of the largest regular (non-control) SID
const SID MAXREGSID = 0xFFFFFFFA;
extern "C" WCHAR const wcsContents[];
//+----------------------------------------------------------------------
//
// Class: CMStream (ms)
//
// Purpose: Main interface to multi-streams
//
// Interface: See below
//
// Notes:
//
//-----------------------------------------------------------------------
class CMStream{public:
CMStream( ILockBytes **pplstParent, USHORT uSectorShift);
~CMStream();
SCODE Init(VOID);
SCODE InitNew(VOID); SCODE InitConvert(VOID);
void Empty(void); inline SCODE CreateEntry( SID const sidParent, CDfName const *pdfn, MSENTRYFLAGS const mefFlags, SID *psid);
// No implementation, currently unused, placeholder
void ReleaseEntry(SID const sid);
inline SCODE DestroyEntry( SID const sidParent, CDfName const *pdfn);
inline SCODE KillStream( SECT sectStart, ULONG ulSize);
inline SCODE RenameEntry( SID const sidParent, CDfName const *pdfn, CDfName const *pdfnNew); inline SCODE IsEntry( SID const sidParent, CDfName const *pdfn, SEntryBuffer *peb);
inline SCODE StatEntry( SID const sid, CDfName *pName, STATSTGW *pstatstg); inline SCODE GetChild( SID const sid, SID *psid);
inline SCODE FindGreaterEntry( SID sidParent, CDfName const *pdfnKey, SID *psid);
inline SCODE GetTime( SID const sid, WHICHTIME const tt, TIME_T *pnt); inline SCODE SetTime( SID const sid, WHICHTIME const tt, TIME_T nt); inline SCODE GetClass( SID const sid, CLSID *pclsid);
inline SCODE SetClass(SID const sid, REFCLSID clsid);
inline SCODE GetStateBits(SID const sd, DWORD *pgrfStateBits);
inline SCODE SetStateBits(SID const sid, DWORD grfStateBits, DWORD grfMask);
inline SCODE GetEntrySize( SID const sid, ULONG *pcbSize);
SCODE GetIterator( SID const sidParent, CMSFIterator **pit);
inline SCODE SetSize(VOID); inline SCODE SetMiniSize(VOID);
SCODE MWrite( SID sid, BOOL fIsMiniStream, ULONG ulOffset, VOID const HUGEP *pBuffer, ULONG ulCount, CStreamCache *pstmc, ULONG *pulRetVal);
SCODE GetName(SID const sid, CDfName *pdfn);
inline CMSFHeader * GetHeader(VOID) const; inline CFat * GetFat(VOID) const; inline CFat * GetMiniFat(VOID) const; inline CDIFat * GetDIFat(VOID) const; inline CDirectory * GetDir(VOID) const; inline CMSFPageTable * GetPageTable(VOID) const;
inline USHORT GetSectorSize(VOID) const; inline USHORT GetSectorShift(VOID) const; inline USHORT GetSectorMask(VOID) const;
SCODE Flush(BOOL fFlushILB); SCODE FlushHeader(USHORT uForce);
inline CDirectStream * GetMiniStream(VOID) const; inline ILockBytes * GetILB(VOID) const;
inline SCODE GetSect(SID sid, SECT sect, SECT *psect); SCODE GetESect(SID sid, SECT sect, SECT *psect);
SCODE SecureSect( const SECT sect, const ULONG ulSize, const BOOL fIsMini); private:
ILockBytes **_pplstParent; CMSFHeader _hdr;
CMSFPageTable *_pmpt;
CDirectory _dir; CFat _fat; CDIFat _fatDif; CFat _fatMini; CDirectStream* _pdsministream;
USHORT _uSectorSize; USHORT _uSectorShift; USHORT _uSectorMask;
SCODE InitCommon(VOID);
SECT GetStart(SID sid) const;
SCODE ConvertILB(SECT sectMax); friend SCODE DllGetScratchMultiStream( CMStream **ppms, ILockBytes **pplstStream, CMStream *pmsMaster);
#ifdef _MSC_VER
#pragma warning(disable:4512)
// default assignment operator could not be generated, which is fine
// since we are not using it.
#endif // _MSC_VER
};
#ifdef _MSC_VER
#pragma warning(default:4512)
#endif // _MSC_VER
//+-------------------------------------------------------------------------
//
// Method: CMStream::GetSectorSize, public
//
// Synopsis: Returns the current sector size
//
//--------------------------------------------------------------------------
inline USHORT CMStream::GetSectorSize(VOID) const{ return _uSectorSize;}
//+-------------------------------------------------------------------------
//
// Method: CMStream::GetSectorShift, public
//
// Synopsis: Returns the current shift for sector math
//
//--------------------------------------------------------------------------
inline USHORT CMStream::GetSectorShift(VOID) const{ return _uSectorShift;}
//+-------------------------------------------------------------------------
//
// Method: CMStream::GetSectorMask, public
//
// Synopsis: Returns the current mask for sector math
//
//--------------------------------------------------------------------------
inline USHORT CMStream::GetSectorMask(VOID) const{ return _uSectorMask;}
//+-------------------------------------------------------------------------
//
// Method: CMStream::GetHeader, public
//
// Synopsis: Returns a pointer to the current header.
//
//--------------------------------------------------------------------------
inline CMSFHeader * CMStream::GetHeader(VOID) const{ return (CMSFHeader *)(&_hdr);}
//+-------------------------------------------------------------------------
//
// Method: CMStream::GetFat, public
//
// Synopsis: Returns a pointer to the current Fat
//
//--------------------------------------------------------------------------
inline CFat * CMStream::GetFat(VOID) const{ return (CFat *)&_fat;}
//+-------------------------------------------------------------------------
//
// Member: CMStream::GetMiniFat
//
// Synopsis: Returns a pointer to the current minifat
//
//--------------------------------------------------------------------------
inline CFat * CMStream::GetMiniFat(VOID) const{ return (CFat *)&_fatMini;}
//+-------------------------------------------------------------------------
//
// Method: CMStream::GetDIFat, public
//
// Synopsis: Returns pointer to the current Double Indirect Fat
//
//--------------------------------------------------------------------------
inline CDIFat * CMStream::GetDIFat(VOID) const{ return (CDIFat *)&_fatDif;}
//+-------------------------------------------------------------------------
//
// Member: CMStream::GetDir
//
// Synopsis: Returns a pointer to the current directory
//
//--------------------------------------------------------------------------
inline CDirectory * CMStream::GetDir(VOID) const{ return (CDirectory *)&_dir;}
//+-------------------------------------------------------------------------
//
// Member: CMStream::GetMiniStream
//
// Synopsis: Returns pointer to the current ministream
//
//--------------------------------------------------------------------------
inline CDirectStream * CMStream::GetMiniStream(VOID) const{ return(_pdsministream);}
//+-------------------------------------------------------------------------
//
// Member: CMStream::GetILB
//
// Synopsis: Returns a pointer to the current parent ILockBytes
//
//--------------------------------------------------------------------------
inline ILockBytes * CMStream::GetILB(VOID) const{ return(*_pplstParent);}
//+-------------------------------------------------------------------------
//
// Member: CMStream::GetPageTable
//
// Synopsis: Returns a pointer to the current page table
//
//--------------------------------------------------------------------------
inline CMSFPageTable * CMStream::GetPageTable(VOID) const{ return _pmpt;}
//+-------------------------------------------------------------------------
//
// Method: CMStream::StatEntry
//
// Synopsis: For a given handle, fill in the Multistream specific
// information of a STATSTG.
//
// Arguments: [sid] -- SID that information is requested on.
// [pName] -- Name of entry to fill in (if not null)
// [pstatstg] -- STATSTG to fill in (if not null)
//
// Returns: S_OK
//
//--------------------------------------------------------------------------
inline SCODE CMStream::StatEntry(SID const sid, CDfName *pName, STATSTGW *pstatstg){ return _dir.StatEntry(sid, pName, pstatstg);}
//+-------------------------------------------------------------------------
//
// Member: CMStream::GetChild, public
//
// Synposis: Return the child SID for a directory entry
//
// Arguments: [sid] - Parent
// [psid] - Child SID return
//
// Returns: Appropriate status code
//
//---------------------------------------------------------------------------
inline SCODE CMStream::GetChild( SID const sid, SID *psid){ return _dir.GetChild(sid, psid);}
//+---------------------------------------------------------------------------
//
// Member: CMStream::FindGreaterEntry, public
//
// Synopsis: Returns the next greater entry for the given parent SID
//
// Arguments: [sidParent] - SID of parent storage
// [CDfName *pdfnKey] - Previous key
// [psid] - Result
//
// Returns: Appropriate status code
//
// Modifies: [psid]
//
//----------------------------------------------------------------------------
inline SCODE CMStream::FindGreaterEntry(SID sidParent, CDfName const *pdfnKey, SID *psid){ return _dir.FindGreaterEntry(sidParent, pdfnKey, psid);}
extern SCODE DllMultiStreamFromStream( CMStream **ppms, ILockBytes **pplstStream, DWORD dwFlags);
extern SCODE DllMultiStreamFromCorruptedStream( CMStream **ppms, ILockBytes **pplstStream, DWORD dwFlags);
extern void DllReleaseMultiStream(CMStream *pms);
extern SCODE DllIsMultiStream(ILockBytes *plstStream);
extern SCODE DllGetCommitSig(ILockBytes *plst, DFSIGNATURE *psig);
extern SCODE DllSetCommitSig(ILockBytes *plst, DFSIGNATURE sig);
#if DEVL == 1
extern VOID SetInfoLevel(ULONG x);#endif
#endif //__MSF_HXX__
|
