mirror of
https://github.com/reactos/wine.git
synced 2024-12-02 00:36:43 +00:00
420f6c0030
the name of the root node stored in the file. When reading streams stored into structured storage files, EOF is not supposed to cause an error if at least one byte can be returned.
874 lines
27 KiB
C
874 lines
27 KiB
C
/*
|
|
* Compound Storage (32 bit version)
|
|
*
|
|
* Implemented using the documentation of the LAOLA project at
|
|
* <URL:http://wwwwbs.cs.tu-berlin.de/~schwartz/pmh/index.html>
|
|
* (Thanks to Martin Schwartz <schwartz@cs.tu-berlin.de>)
|
|
*
|
|
* This include file contains definitions of types and function
|
|
* prototypes that are used in the many files implementing the
|
|
* storage functionality
|
|
*
|
|
* Copyright 1998,1999 Francis Beaudet
|
|
* Copyright 1998,1999 Thuy Nguyen
|
|
*/
|
|
#ifndef __STORAGE32_H__
|
|
#define __STORAGE32_H__
|
|
|
|
#include "wtypes.h"
|
|
#include "winnt.h"
|
|
#include "wine/obj_base.h"
|
|
#include "wine/obj_storage.h"
|
|
|
|
/*
|
|
* Definitions for the file format offsets.
|
|
*/
|
|
static const ULONG OFFSET_BIGBLOCKSIZEBITS = 0x0000001e;
|
|
static const ULONG OFFSET_SMALLBLOCKSIZEBITS = 0x00000020;
|
|
static const ULONG OFFSET_BBDEPOTCOUNT = 0x0000002C;
|
|
static const ULONG OFFSET_ROOTSTARTBLOCK = 0x00000030;
|
|
static const ULONG OFFSET_SBDEPOTSTART = 0x0000003C;
|
|
static const ULONG OFFSET_EXTBBDEPOTSTART = 0x00000044;
|
|
static const ULONG OFFSET_EXTBBDEPOTCOUNT = 0x00000048;
|
|
static const ULONG OFFSET_BBDEPOTSTART = 0x0000004C;
|
|
static const ULONG OFFSET_PS_NAME = 0x00000000;
|
|
static const ULONG OFFSET_PS_NAMELENGTH = 0x00000040;
|
|
static const ULONG OFFSET_PS_PROPERTYTYPE = 0x00000042;
|
|
static const ULONG OFFSET_PS_PREVIOUSPROP = 0x00000044;
|
|
static const ULONG OFFSET_PS_NEXTPROP = 0x00000048;
|
|
static const ULONG OFFSET_PS_DIRPROP = 0x0000004C;
|
|
static const ULONG OFFSET_PS_GUID = 0x00000050;
|
|
static const ULONG OFFSET_PS_TSS1 = 0x00000064;
|
|
static const ULONG OFFSET_PS_TSD1 = 0x00000068;
|
|
static const ULONG OFFSET_PS_TSS2 = 0x0000006C;
|
|
static const ULONG OFFSET_PS_TSD2 = 0x00000070;
|
|
static const ULONG OFFSET_PS_STARTBLOCK = 0x00000074;
|
|
static const ULONG OFFSET_PS_SIZE = 0x00000078;
|
|
static const WORD DEF_BIG_BLOCK_SIZE_BITS = 0x0009;
|
|
static const WORD DEF_SMALL_BLOCK_SIZE_BITS = 0x0006;
|
|
static const WORD DEF_BIG_BLOCK_SIZE = 0x0200;
|
|
static const WORD DEF_SMALL_BLOCK_SIZE = 0x0040;
|
|
static const ULONG BLOCK_EXTBBDEPOT = 0xFFFFFFFC;
|
|
static const ULONG BLOCK_SPECIAL = 0xFFFFFFFD;
|
|
static const ULONG BLOCK_END_OF_CHAIN = 0xFFFFFFFE;
|
|
static const ULONG BLOCK_UNUSED = 0xFFFFFFFF;
|
|
static const ULONG PROPERTY_NULL = 0xFFFFFFFF;
|
|
|
|
#define PROPERTY_NAME_MAX_LEN 0x20
|
|
#define PROPERTY_NAME_BUFFER_LEN 0x40
|
|
|
|
#define PROPSET_BLOCK_SIZE 0x00000080
|
|
|
|
/*
|
|
* Property type of relation
|
|
*/
|
|
#define PROPERTY_RELATION_PREVIOUS 0
|
|
#define PROPERTY_RELATION_NEXT 1
|
|
#define PROPERTY_RELATION_DIR 2
|
|
|
|
/*
|
|
* Property type constants
|
|
*/
|
|
#define PROPTYPE_STORAGE 0x01
|
|
#define PROPTYPE_STREAM 0x02
|
|
#define PROPTYPE_ROOT 0x05
|
|
|
|
/*
|
|
* These defines assume a hardcoded blocksize. The code will assert
|
|
* if the blocksize is different. Some changes will have to be done if it
|
|
* becomes the case.
|
|
*/
|
|
#define BIG_BLOCK_SIZE 0x200
|
|
#define COUNT_BBDEPOTINHEADER 109
|
|
#define LIMIT_TO_USE_SMALL_BLOCK 0x1000
|
|
#define NUM_BLOCKS_PER_DEPOT_BLOCK 128
|
|
|
|
/*
|
|
* These are signatures to detect the type of Document file.
|
|
*/
|
|
static const BYTE STORAGE_magic[8] ={0xd0,0xcf,0x11,0xe0,0xa1,0xb1,0x1a,0xe1};
|
|
static const BYTE STORAGE_oldmagic[8] ={0xd0,0xcf,0x11,0xe0,0x0e,0x11,0xfc,0x0d};
|
|
|
|
/*
|
|
* Forward declarations of all the structures used by the storage
|
|
* module.
|
|
*/
|
|
typedef struct StorageBaseImpl StorageBaseImpl;
|
|
typedef struct StorageImpl StorageImpl;
|
|
typedef struct StorageInternalImpl StorageInternalImpl;
|
|
typedef struct BlockChainStream BlockChainStream;
|
|
typedef struct SmallBlockChainStream SmallBlockChainStream;
|
|
typedef struct IEnumSTATSTGImpl IEnumSTATSTGImpl;
|
|
typedef struct StgProperty StgProperty;
|
|
typedef struct StgStreamImpl StgStreamImpl;
|
|
|
|
/*
|
|
* This utility structure is used to read/write the information in a storage
|
|
* property.
|
|
*/
|
|
struct StgProperty
|
|
{
|
|
WCHAR name[PROPERTY_NAME_MAX_LEN];
|
|
WORD sizeOfNameString;
|
|
BYTE propertyType;
|
|
ULONG previousProperty;
|
|
ULONG nextProperty;
|
|
ULONG dirProperty;
|
|
GUID propertyUniqueID;
|
|
ULONG timeStampS1;
|
|
ULONG timeStampD1;
|
|
ULONG timeStampS2;
|
|
ULONG timeStampD2;
|
|
ULONG startingBlock;
|
|
ULARGE_INTEGER size;
|
|
};
|
|
|
|
/*************************************************************************
|
|
* Big Block File support
|
|
*
|
|
* The big block file is an abstraction of a flat file separated in
|
|
* same sized blocks. The implementation for the methods described in
|
|
* this section appear in stg_bigblockfile.c
|
|
*/
|
|
|
|
/*
|
|
* Declaration of the data structures
|
|
*/
|
|
typedef struct BigBlockFile BigBlockFile,*LPBIGBLOCKFILE;
|
|
typedef struct MappedPage MappedPage,*LPMAPPEDPAGE;
|
|
|
|
struct BigBlockFile
|
|
{
|
|
BOOL fileBased;
|
|
ULARGE_INTEGER filesize;
|
|
ULONG blocksize;
|
|
HANDLE hfile;
|
|
HANDLE hfilemap;
|
|
DWORD flProtect;
|
|
MappedPage *maplist;
|
|
MappedPage *victimhead, *victimtail;
|
|
ULONG num_victim_pages;
|
|
ILockBytes *pLkbyt;
|
|
HGLOBAL hbytearray;
|
|
LPVOID pbytearray;
|
|
};
|
|
|
|
/*
|
|
* Declaration of the functions used to manipulate the BigBlockFile
|
|
* data structure.
|
|
*/
|
|
BigBlockFile* BIGBLOCKFILE_Construct(HANDLE hFile,
|
|
ILockBytes* pLkByt,
|
|
DWORD openFlags,
|
|
ULONG blocksize,
|
|
BOOL fileBased);
|
|
void BIGBLOCKFILE_Destructor(LPBIGBLOCKFILE This);
|
|
void* BIGBLOCKFILE_GetBigBlock(LPBIGBLOCKFILE This, ULONG index);
|
|
void* BIGBLOCKFILE_GetROBigBlock(LPBIGBLOCKFILE This, ULONG index);
|
|
void BIGBLOCKFILE_ReleaseBigBlock(LPBIGBLOCKFILE This, void *pBlock);
|
|
void BIGBLOCKFILE_SetSize(LPBIGBLOCKFILE This, ULARGE_INTEGER newSize);
|
|
ULARGE_INTEGER BIGBLOCKFILE_GetSize(LPBIGBLOCKFILE This);
|
|
|
|
/*************************************************************************
|
|
* Ole Convert support
|
|
*/
|
|
|
|
void OLECONVERT_CreateOleStream(LPSTORAGE pStorage);
|
|
HRESULT OLECONVERT_CreateCompObjStream(LPSTORAGE pStorage, LPCSTR strOleTypeName);
|
|
|
|
/****************************************************************************
|
|
* Storage32BaseImpl definitions.
|
|
*
|
|
* This stucture defines the base information contained in all implementations
|
|
* of IStorage32 contained in this filee storage implementation.
|
|
*
|
|
* In OOP terms, this is the base class for all the IStorage32 implementations
|
|
* contained in this file.
|
|
*/
|
|
struct StorageBaseImpl
|
|
{
|
|
ICOM_VFIELD(IStorage); /* Needs to be the first item in the stuct
|
|
* since we want to cast this in a Storage32 pointer */
|
|
|
|
/*
|
|
* Reference count of this object
|
|
*/
|
|
ULONG ref;
|
|
|
|
/*
|
|
* Ancestor storage (top level)
|
|
*/
|
|
StorageImpl* ancestorStorage;
|
|
|
|
/*
|
|
* Index of the property for the root of
|
|
* this storage
|
|
*/
|
|
ULONG rootPropertySetIndex;
|
|
|
|
/*
|
|
* virtual Destructor method.
|
|
*/
|
|
void (*v_destructor)(StorageBaseImpl*);
|
|
};
|
|
|
|
|
|
/*
|
|
* Prototypes for the methods of the Storage32BaseImpl class.
|
|
*/
|
|
HRESULT WINAPI StorageBaseImpl_QueryInterface(
|
|
IStorage* iface,
|
|
REFIID riid,
|
|
void** ppvObject);
|
|
|
|
ULONG WINAPI StorageBaseImpl_AddRef(
|
|
IStorage* iface);
|
|
|
|
ULONG WINAPI StorageBaseImpl_Release(
|
|
IStorage* iface);
|
|
|
|
HRESULT WINAPI StorageBaseImpl_OpenStream(
|
|
IStorage* iface,
|
|
const OLECHAR* pwcsName, /* [string][in] */
|
|
void* reserved1, /* [unique][in] */
|
|
DWORD grfMode, /* [in] */
|
|
DWORD reserved2, /* [in] */
|
|
IStream** ppstm); /* [out] */
|
|
|
|
HRESULT WINAPI StorageBaseImpl_OpenStorage(
|
|
IStorage* iface,
|
|
const OLECHAR* pwcsName, /* [string][unique][in] */
|
|
IStorage* pstgPriority, /* [unique][in] */
|
|
DWORD grfMode, /* [in] */
|
|
SNB snbExclude, /* [unique][in] */
|
|
DWORD reserved, /* [in] */
|
|
IStorage** ppstg); /* [out] */
|
|
|
|
HRESULT WINAPI StorageBaseImpl_EnumElements(
|
|
IStorage* iface,
|
|
DWORD reserved1, /* [in] */
|
|
void* reserved2, /* [size_is][unique][in] */
|
|
DWORD reserved3, /* [in] */
|
|
IEnumSTATSTG** ppenum); /* [out] */
|
|
|
|
HRESULT WINAPI StorageBaseImpl_Stat(
|
|
IStorage* iface,
|
|
STATSTG* pstatstg, /* [out] */
|
|
DWORD grfStatFlag); /* [in] */
|
|
|
|
HRESULT WINAPI StorageBaseImpl_RenameElement(
|
|
IStorage* iface,
|
|
const OLECHAR* pwcsOldName, /* [string][in] */
|
|
const OLECHAR* pwcsNewName); /* [string][in] */
|
|
|
|
HRESULT WINAPI StorageBaseImpl_CreateStream(
|
|
IStorage* iface,
|
|
const OLECHAR* pwcsName, /* [string][in] */
|
|
DWORD grfMode, /* [in] */
|
|
DWORD reserved1, /* [in] */
|
|
DWORD reserved2, /* [in] */
|
|
IStream** ppstm); /* [out] */
|
|
|
|
HRESULT WINAPI StorageBaseImpl_SetClass(
|
|
IStorage* iface,
|
|
REFCLSID clsid); /* [in] */
|
|
|
|
/****************************************************************************
|
|
* Storage32Impl definitions.
|
|
*
|
|
* This implementation of the IStorage32 interface represents a root
|
|
* storage. Basically, a document file.
|
|
*/
|
|
struct StorageImpl
|
|
{
|
|
ICOM_VFIELD(IStorage); /* Needs to be the first item in the stuct
|
|
* since we want to cast this in a Storage32 pointer */
|
|
|
|
/*
|
|
* Declare the member of the Storage32BaseImpl class to allow
|
|
* casting as a Storage32BaseImpl
|
|
*/
|
|
ULONG ref;
|
|
struct StorageImpl* ancestorStorage;
|
|
ULONG rootPropertySetIndex;
|
|
void (*v_destructor)(struct StorageImpl*);
|
|
|
|
/*
|
|
* The following data members are specific to the Storage32Impl
|
|
* class
|
|
*/
|
|
HANDLE hFile; /* Physical support for the Docfile */
|
|
LPOLESTR pwcsName; /* Full path of the document file */
|
|
|
|
/*
|
|
* File header
|
|
*/
|
|
WORD bigBlockSizeBits;
|
|
WORD smallBlockSizeBits;
|
|
ULONG bigBlockSize;
|
|
ULONG smallBlockSize;
|
|
ULONG bigBlockDepotCount;
|
|
ULONG rootStartBlock;
|
|
ULONG smallBlockDepotStart;
|
|
ULONG extBigBlockDepotStart;
|
|
ULONG extBigBlockDepotCount;
|
|
ULONG bigBlockDepotStart[COUNT_BBDEPOTINHEADER];
|
|
|
|
ULONG blockDepotCached[NUM_BLOCKS_PER_DEPOT_BLOCK];
|
|
ULONG indexBlockDepotCached;
|
|
ULONG prevFreeBlock;
|
|
|
|
/*
|
|
* Abstraction of the big block chains for the chains of the header.
|
|
*/
|
|
BlockChainStream* rootBlockChain;
|
|
BlockChainStream* smallBlockDepotChain;
|
|
BlockChainStream* smallBlockRootChain;
|
|
|
|
/*
|
|
* Pointer to the big block file abstraction
|
|
*/
|
|
BigBlockFile* bigBlockFile;
|
|
};
|
|
|
|
/*
|
|
* Method declaration for the Storage32Impl class
|
|
*/
|
|
|
|
HRESULT WINAPI StorageImpl_CreateStorage(
|
|
IStorage* iface,
|
|
const OLECHAR* pwcsName, /* [string][in] */
|
|
DWORD grfMode, /* [in] */
|
|
DWORD dwStgFmt, /* [in] */
|
|
DWORD reserved2, /* [in] */
|
|
IStorage** ppstg); /* [out] */
|
|
|
|
HRESULT WINAPI StorageImpl_CopyTo(
|
|
IStorage* iface,
|
|
DWORD ciidExclude, /* [in] */
|
|
const IID* rgiidExclude, /* [size_is][unique][in] */
|
|
SNB snbExclude, /* [unique][in] */
|
|
IStorage* pstgDest); /* [unique][in] */
|
|
|
|
HRESULT WINAPI StorageImpl_MoveElementTo(
|
|
IStorage* iface,
|
|
const OLECHAR* pwcsName, /* [string][in] */
|
|
IStorage* pstgDest, /* [unique][in] */
|
|
const OLECHAR* pwcsNewName, /* [string][in] */
|
|
DWORD grfFlags); /* [in] */
|
|
|
|
HRESULT WINAPI StorageImpl_Commit(
|
|
IStorage* iface,
|
|
DWORD grfCommitFlags); /* [in] */
|
|
|
|
HRESULT WINAPI StorageImpl_Revert(
|
|
IStorage* iface);
|
|
|
|
HRESULT WINAPI StorageImpl_DestroyElement(
|
|
IStorage* iface,
|
|
const OLECHAR* pwcsName); /* [string][in] */
|
|
|
|
HRESULT WINAPI StorageImpl_SetElementTimes(
|
|
IStorage* iface,
|
|
const OLECHAR* pwcsName, /* [string][in] */
|
|
const FILETIME* pctime, /* [in] */
|
|
const FILETIME* patime, /* [in] */
|
|
const FILETIME* pmtime); /* [in] */
|
|
|
|
HRESULT WINAPI StorageImpl_SetStateBits(
|
|
IStorage* iface,
|
|
DWORD grfStateBits, /* [in] */
|
|
DWORD grfMask); /* [in] */
|
|
|
|
HRESULT WINAPI StorageImpl_Stat(IStorage* iface,
|
|
STATSTG* pstatstg, /* [out] */
|
|
DWORD grfStatFlag); /* [in] */
|
|
|
|
void StorageImpl_Destroy(
|
|
StorageImpl* This);
|
|
|
|
HRESULT StorageImpl_Construct(
|
|
StorageImpl* This,
|
|
HANDLE hFile,
|
|
LPCOLESTR pwcsName,
|
|
ILockBytes* pLkbyt,
|
|
DWORD openFlags,
|
|
BOOL fileBased,
|
|
BOOL fileCreate);
|
|
|
|
BOOL StorageImpl_ReadBigBlock(
|
|
StorageImpl* This,
|
|
ULONG blockIndex,
|
|
void* buffer);
|
|
|
|
BOOL StorageImpl_WriteBigBlock(
|
|
StorageImpl* This,
|
|
ULONG blockIndex,
|
|
void* buffer);
|
|
|
|
void* StorageImpl_GetROBigBlock(
|
|
StorageImpl* This,
|
|
ULONG blockIndex);
|
|
|
|
void* StorageImpl_GetBigBlock(
|
|
StorageImpl* This,
|
|
ULONG blockIndex);
|
|
|
|
void StorageImpl_ReleaseBigBlock(
|
|
StorageImpl* This,
|
|
void* pBigBlock);
|
|
|
|
ULONG StorageImpl_GetNextFreeBigBlock(
|
|
StorageImpl* This);
|
|
|
|
void StorageImpl_FreeBigBlock(
|
|
StorageImpl* This,
|
|
ULONG blockIndex);
|
|
|
|
ULONG StorageImpl_GetNextBlockInChain(
|
|
StorageImpl* This,
|
|
ULONG blockIndex);
|
|
|
|
void StorageImpl_SetNextBlockInChain(
|
|
StorageImpl* This,
|
|
ULONG blockIndex,
|
|
ULONG nextBlock);
|
|
|
|
HRESULT StorageImpl_LoadFileHeader(
|
|
StorageImpl* This);
|
|
|
|
void StorageImpl_SaveFileHeader(
|
|
StorageImpl* This);
|
|
|
|
BOOL StorageImpl_ReadProperty(
|
|
StorageImpl* This,
|
|
ULONG index,
|
|
StgProperty* buffer);
|
|
|
|
BOOL StorageImpl_WriteProperty(
|
|
StorageImpl* This,
|
|
ULONG index,
|
|
StgProperty* buffer);
|
|
|
|
BlockChainStream* Storage32Impl_SmallBlocksToBigBlocks(
|
|
StorageImpl* This,
|
|
SmallBlockChainStream** ppsbChain);
|
|
|
|
ULONG Storage32Impl_GetNextExtendedBlock(StorageImpl* This,
|
|
ULONG blockIndex);
|
|
|
|
void Storage32Impl_AddBlockDepot(StorageImpl* This,
|
|
ULONG blockIndex);
|
|
|
|
ULONG Storage32Impl_AddExtBlockDepot(StorageImpl* This);
|
|
|
|
ULONG Storage32Impl_GetExtDepotBlock(StorageImpl* This,
|
|
ULONG depotIndex);
|
|
|
|
void Storage32Impl_SetExtDepotBlock(StorageImpl* This,
|
|
ULONG depotIndex,
|
|
ULONG blockIndex);
|
|
/****************************************************************************
|
|
* Storage32InternalImpl definitions.
|
|
*
|
|
* Definition of the implementation structure for the IStorage32 interface.
|
|
* This one implements the IStorage32 interface for storage that are
|
|
* inside another storage.
|
|
*/
|
|
struct StorageInternalImpl
|
|
{
|
|
ICOM_VFIELD(IStorage); /* Needs to be the first item in the stuct
|
|
* since we want to cast this in a Storage32 pointer */
|
|
|
|
/*
|
|
* Declare the member of the Storage32BaseImpl class to allow
|
|
* casting as a Storage32BaseImpl
|
|
*/
|
|
ULONG ref;
|
|
struct StorageImpl* ancestorStorage;
|
|
ULONG rootPropertySetIndex;
|
|
void (*v_destructor)(struct StorageInternalImpl*);
|
|
|
|
/*
|
|
* There is no specific data for this class.
|
|
*/
|
|
};
|
|
|
|
/*
|
|
* Method definitions for the Storage32InternalImpl class.
|
|
*/
|
|
StorageInternalImpl* StorageInternalImpl_Construct(
|
|
StorageImpl* ancestorStorage,
|
|
ULONG rootTropertyIndex);
|
|
|
|
void StorageInternalImpl_Destroy(
|
|
StorageInternalImpl* This);
|
|
|
|
HRESULT WINAPI StorageInternalImpl_Commit(
|
|
IStorage* iface,
|
|
DWORD grfCommitFlags); /* [in] */
|
|
|
|
HRESULT WINAPI StorageInternalImpl_Revert(
|
|
IStorage* iface);
|
|
|
|
|
|
/****************************************************************************
|
|
* IEnumSTATSTGImpl definitions.
|
|
*
|
|
* Definition of the implementation structure for the IEnumSTATSTGImpl interface.
|
|
* This class allows iterating through the content of a storage and to find
|
|
* specific items inside it.
|
|
*/
|
|
struct IEnumSTATSTGImpl
|
|
{
|
|
ICOM_VFIELD(IEnumSTATSTG); /* Needs to be the first item in the stuct
|
|
* since we want to cast this in a IEnumSTATSTG pointer */
|
|
|
|
ULONG ref; /* Reference count */
|
|
StorageImpl* parentStorage; /* Reference to the parent storage */
|
|
ULONG firstPropertyNode; /* Index of the root of the storage to enumerate */
|
|
|
|
/*
|
|
* The current implementation of the IEnumSTATSTGImpl class uses a stack
|
|
* to walk the property sets to get the content of a storage. This stack
|
|
* is implemented by the following 3 data members
|
|
*/
|
|
ULONG stackSize;
|
|
ULONG stackMaxSize;
|
|
ULONG* stackToVisit;
|
|
|
|
#define ENUMSTATSGT_SIZE_INCREMENT 10
|
|
};
|
|
|
|
/*
|
|
* Method definitions for the IEnumSTATSTGImpl class.
|
|
*/
|
|
HRESULT WINAPI IEnumSTATSTGImpl_QueryInterface(
|
|
IEnumSTATSTG* iface,
|
|
REFIID riid,
|
|
void** ppvObject);
|
|
|
|
ULONG WINAPI IEnumSTATSTGImpl_AddRef(
|
|
IEnumSTATSTG* iface);
|
|
|
|
ULONG WINAPI IEnumSTATSTGImpl_Release(
|
|
IEnumSTATSTG* iface);
|
|
|
|
HRESULT WINAPI IEnumSTATSTGImpl_Next(
|
|
IEnumSTATSTG* iface,
|
|
ULONG celt,
|
|
STATSTG* rgelt,
|
|
ULONG* pceltFetched);
|
|
|
|
HRESULT WINAPI IEnumSTATSTGImpl_Skip(
|
|
IEnumSTATSTG* iface,
|
|
ULONG celt);
|
|
|
|
HRESULT WINAPI IEnumSTATSTGImpl_Reset(
|
|
IEnumSTATSTG* iface);
|
|
|
|
HRESULT WINAPI IEnumSTATSTGImpl_Clone(
|
|
IEnumSTATSTG* iface,
|
|
IEnumSTATSTG** ppenum);
|
|
|
|
IEnumSTATSTGImpl* IEnumSTATSTGImpl_Construct(
|
|
StorageImpl* This,
|
|
ULONG firstPropertyNode);
|
|
|
|
void IEnumSTATSTGImpl_Destroy(
|
|
IEnumSTATSTGImpl* This);
|
|
|
|
void IEnumSTATSTGImpl_PushSearchNode(
|
|
IEnumSTATSTGImpl* This,
|
|
ULONG nodeToPush);
|
|
|
|
ULONG IEnumSTATSTGImpl_PopSearchNode(
|
|
IEnumSTATSTGImpl* This,
|
|
BOOL remove);
|
|
|
|
ULONG IEnumSTATSTGImpl_FindProperty(
|
|
IEnumSTATSTGImpl* This,
|
|
const OLECHAR* lpszPropName,
|
|
StgProperty* buffer);
|
|
|
|
INT IEnumSTATSTGImpl_FindParentProperty(
|
|
IEnumSTATSTGImpl *This,
|
|
ULONG childProperty,
|
|
StgProperty *currentProperty,
|
|
ULONG *propertyId);
|
|
|
|
|
|
/****************************************************************************
|
|
* StgStreamImpl definitions.
|
|
*
|
|
* This class imlements the IStream32 inteface and represents a stream
|
|
* located inside a storage object.
|
|
*/
|
|
struct StgStreamImpl
|
|
{
|
|
ICOM_VFIELD(IStream); /* Needs to be the first item in the stuct
|
|
* since we want to cast this in a IStream pointer */
|
|
|
|
/*
|
|
* Reference count
|
|
*/
|
|
ULONG ref;
|
|
|
|
/*
|
|
* Storage that is the parent(owner) of the stream
|
|
*/
|
|
StorageBaseImpl* parentStorage;
|
|
|
|
/*
|
|
* Access mode of this stream.
|
|
*/
|
|
DWORD grfMode;
|
|
|
|
/*
|
|
* Index of the property that owns (points to) this stream.
|
|
*/
|
|
ULONG ownerProperty;
|
|
|
|
/*
|
|
* Helper variable that contains the size of the stream
|
|
*/
|
|
ULARGE_INTEGER streamSize;
|
|
|
|
/*
|
|
* This is the current position of the cursor in the stream
|
|
*/
|
|
ULARGE_INTEGER currentPosition;
|
|
|
|
/*
|
|
* The information in the stream is represented by a chain of small blocks
|
|
* or a chain of large blocks. Depending on the case, one of the two
|
|
* following variabled points to that information.
|
|
*/
|
|
BlockChainStream* bigBlockChain;
|
|
SmallBlockChainStream* smallBlockChain;
|
|
};
|
|
|
|
/*
|
|
* Method definition for the StgStreamImpl class.
|
|
*/
|
|
StgStreamImpl* StgStreamImpl_Construct(
|
|
StorageBaseImpl* parentStorage,
|
|
DWORD grfMode,
|
|
ULONG ownerProperty);
|
|
|
|
void StgStreamImpl_Destroy(
|
|
StgStreamImpl* This);
|
|
|
|
void StgStreamImpl_OpenBlockChain(
|
|
StgStreamImpl* This);
|
|
|
|
HRESULT WINAPI StgStreamImpl_QueryInterface(
|
|
IStream* iface,
|
|
REFIID riid, /* [in] */
|
|
void** ppvObject); /* [iid_is][out] */
|
|
|
|
ULONG WINAPI StgStreamImpl_AddRef(
|
|
IStream* iface);
|
|
|
|
ULONG WINAPI StgStreamImpl_Release(
|
|
IStream* iface);
|
|
|
|
HRESULT WINAPI StgStreamImpl_Read(
|
|
IStream* iface,
|
|
void* pv, /* [length_is][size_is][out] */
|
|
ULONG cb, /* [in] */
|
|
ULONG* pcbRead); /* [out] */
|
|
|
|
HRESULT WINAPI StgStreamImpl_Write(
|
|
IStream* iface,
|
|
const void* pv, /* [size_is][in] */
|
|
ULONG cb, /* [in] */
|
|
ULONG* pcbWritten); /* [out] */
|
|
|
|
HRESULT WINAPI StgStreamImpl_Seek(
|
|
IStream* iface,
|
|
LARGE_INTEGER dlibMove, /* [in] */
|
|
DWORD dwOrigin, /* [in] */
|
|
ULARGE_INTEGER* plibNewPosition); /* [out] */
|
|
|
|
HRESULT WINAPI StgStreamImpl_SetSize(
|
|
IStream* iface,
|
|
ULARGE_INTEGER libNewSize); /* [in] */
|
|
|
|
HRESULT WINAPI StgStreamImpl_CopyTo(
|
|
IStream* iface,
|
|
IStream* pstm, /* [unique][in] */
|
|
ULARGE_INTEGER cb, /* [in] */
|
|
ULARGE_INTEGER* pcbRead, /* [out] */
|
|
ULARGE_INTEGER* pcbWritten); /* [out] */
|
|
|
|
HRESULT WINAPI StgStreamImpl_Commit(
|
|
IStream* iface,
|
|
DWORD grfCommitFlags); /* [in] */
|
|
|
|
HRESULT WINAPI StgStreamImpl_Revert(
|
|
IStream* iface);
|
|
|
|
HRESULT WINAPI StgStreamImpl_LockRegion(
|
|
IStream* iface,
|
|
ULARGE_INTEGER libOffset, /* [in] */
|
|
ULARGE_INTEGER cb, /* [in] */
|
|
DWORD dwLockType); /* [in] */
|
|
|
|
HRESULT WINAPI StgStreamImpl_UnlockRegion(
|
|
IStream* iface,
|
|
ULARGE_INTEGER libOffset, /* [in] */
|
|
ULARGE_INTEGER cb, /* [in] */
|
|
DWORD dwLockType); /* [in] */
|
|
|
|
HRESULT WINAPI StgStreamImpl_Stat(
|
|
IStream* iface,
|
|
STATSTG* pstatstg, /* [out] */
|
|
DWORD grfStatFlag); /* [in] */
|
|
|
|
HRESULT WINAPI StgStreamImpl_Clone(
|
|
IStream* iface,
|
|
IStream** ppstm); /* [out] */
|
|
|
|
|
|
/********************************************************************************
|
|
* The StorageUtl_ functions are miscelaneous utility functions. Most of which are
|
|
* abstractions used to read values from file buffers without having to worry
|
|
* about bit order
|
|
*/
|
|
void StorageUtl_ReadWord(void* buffer, ULONG offset, WORD* value);
|
|
void StorageUtl_WriteWord(void* buffer, ULONG offset, WORD value);
|
|
void StorageUtl_ReadDWord(void* buffer, ULONG offset, DWORD* value);
|
|
void StorageUtl_WriteDWord(void* buffer, ULONG offset, DWORD value);
|
|
void StorageUtl_ReadGUID(void* buffer, ULONG offset, GUID* value);
|
|
void StorageUtl_WriteGUID(void* buffer, ULONG offset, GUID* value);
|
|
void StorageUtl_CopyPropertyToSTATSTG(STATSTG* destination,
|
|
StgProperty* source,
|
|
int statFlags);
|
|
|
|
/****************************************************************************
|
|
* BlockChainStream definitions.
|
|
*
|
|
* The BlockChainStream class is a utility class that is used to create an
|
|
* abstraction of the big block chains in the storage file.
|
|
*/
|
|
struct BlockChainStream
|
|
{
|
|
StorageImpl* parentStorage;
|
|
ULONG* headOfStreamPlaceHolder;
|
|
ULONG ownerPropertyIndex;
|
|
ULONG lastBlockNoInSequence;
|
|
ULONG lastBlockNoInSequenceIndex;
|
|
ULONG tailIndex;
|
|
ULONG numBlocks;
|
|
};
|
|
|
|
/*
|
|
* Methods for the BlockChainStream class.
|
|
*/
|
|
BlockChainStream* BlockChainStream_Construct(
|
|
StorageImpl* parentStorage,
|
|
ULONG* headOfStreamPlaceHolder,
|
|
ULONG propertyIndex);
|
|
|
|
void BlockChainStream_Destroy(
|
|
BlockChainStream* This);
|
|
|
|
ULONG BlockChainStream_GetHeadOfChain(
|
|
BlockChainStream* This);
|
|
|
|
BOOL BlockChainStream_ReadAt(
|
|
BlockChainStream* This,
|
|
ULARGE_INTEGER offset,
|
|
ULONG size,
|
|
void* buffer,
|
|
ULONG* bytesRead);
|
|
|
|
BOOL BlockChainStream_WriteAt(
|
|
BlockChainStream* This,
|
|
ULARGE_INTEGER offset,
|
|
ULONG size,
|
|
const void* buffer,
|
|
ULONG* bytesWritten);
|
|
|
|
BOOL BlockChainStream_SetSize(
|
|
BlockChainStream* This,
|
|
ULARGE_INTEGER newSize);
|
|
|
|
ULARGE_INTEGER BlockChainStream_GetSize(
|
|
BlockChainStream* This);
|
|
|
|
ULONG BlockChainStream_GetCount(
|
|
BlockChainStream* This);
|
|
|
|
/****************************************************************************
|
|
* SmallBlockChainStream definitions.
|
|
*
|
|
* The SmallBlockChainStream class is a utility class that is used to create an
|
|
* abstraction of the small block chains in the storage file.
|
|
*/
|
|
struct SmallBlockChainStream
|
|
{
|
|
StorageImpl* parentStorage;
|
|
ULONG ownerPropertyIndex;
|
|
};
|
|
|
|
/*
|
|
* Methods of the SmallBlockChainStream class.
|
|
*/
|
|
SmallBlockChainStream* SmallBlockChainStream_Construct(
|
|
StorageImpl* parentStorage,
|
|
ULONG propertyIndex);
|
|
|
|
void SmallBlockChainStream_Destroy(
|
|
SmallBlockChainStream* This);
|
|
|
|
ULONG SmallBlockChainStream_GetHeadOfChain(
|
|
SmallBlockChainStream* This);
|
|
|
|
ULONG SmallBlockChainStream_GetNextBlockInChain(
|
|
SmallBlockChainStream* This,
|
|
ULONG blockIndex);
|
|
|
|
void SmallBlockChainStream_SetNextBlockInChain(
|
|
SmallBlockChainStream* This,
|
|
ULONG blockIndex,
|
|
ULONG nextBlock);
|
|
|
|
void SmallBlockChainStream_FreeBlock(
|
|
SmallBlockChainStream* This,
|
|
ULONG blockIndex);
|
|
|
|
ULONG SmallBlockChainStream_GetNextFreeBlock(
|
|
SmallBlockChainStream* This);
|
|
|
|
BOOL SmallBlockChainStream_ReadAt(
|
|
SmallBlockChainStream* This,
|
|
ULARGE_INTEGER offset,
|
|
ULONG size,
|
|
void* buffer,
|
|
ULONG* bytesRead);
|
|
|
|
BOOL SmallBlockChainStream_WriteAt(
|
|
SmallBlockChainStream* This,
|
|
ULARGE_INTEGER offset,
|
|
ULONG size,
|
|
const void* buffer,
|
|
ULONG* bytesWritten);
|
|
|
|
BOOL SmallBlockChainStream_SetSize(
|
|
SmallBlockChainStream* This,
|
|
ULARGE_INTEGER newSize);
|
|
|
|
ULARGE_INTEGER SmallBlockChainStream_GetSize(
|
|
SmallBlockChainStream* This);
|
|
|
|
ULONG SmallBlockChainStream_GetCount(
|
|
SmallBlockChainStream* This);
|
|
|
|
|
|
#endif /* __STORAGE32_H__ */
|
|
|
|
|
|
|