diff --git a/reactos/lib/ole32/include/compobj.h b/reactos/lib/ole32/include/compobj.h new file mode 100644 index 00000000000..b58041b15f5 --- /dev/null +++ b/reactos/lib/ole32/include/compobj.h @@ -0,0 +1,15 @@ +#ifndef __WINE_OLE_COMPOBJ_H +#define __WINE_OLE_COMPOBJ_H + +/* All private prototype functions used by OLE will be added to this header file */ + +/* This function initialize the Running Object Table */ +HRESULT WINAPI RunningObjectTableImpl_Initialize(); + +/* This function uninitialize the Running Object Table */ +HRESULT WINAPI RunningObjectTableImpl_UnInitialize(); + +/* This function decomposes a String path to a String Table containing all the elements ("\" or "subDirectory" or "Directory" or "FileName") of the path */ +int WINAPI FileMonikerImpl_DecomposePath(LPOLESTR str, LPOLESTR** stringTable); + +#endif /* __WINE_OLE_COMPOBJ_H */ diff --git a/reactos/lib/ole32/include/debug.h b/reactos/lib/ole32/include/debug.h new file mode 100644 index 00000000000..77a820bb79a --- /dev/null +++ b/reactos/lib/ole32/include/debug.h @@ -0,0 +1,91 @@ +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS WinSock 2 DLL + * FILE: include/debug.h + * PURPOSE: Debugging support macros + * DEFINES: DBG - Enable debug output + * NASSERT - Disable assertions + */ +#ifndef __DEBUG_H +#define __DEBUG_H + +#define NORMAL_MASK 0x000000FF +#define SPECIAL_MASK 0xFFFFFF00 +#define MIN_TRACE 0x00000001 +#define MID_TRACE 0x00000002 +#define MAX_TRACE 0x00000003 + +#define DEBUG_CHECK 0x00000100 +#define DEBUG_ULTRA 0xFFFFFFFF + +#ifdef DBG + +extern DWORD DebugTraceLevel; + +#define Print(_t_, _x_) \ + if (((DebugTraceLevel & NORMAL_MASK) >= _t_) || \ + ((DebugTraceLevel & _t_) > NORMAL_MASK)) { \ + DbgPrint("(%hS:%d)(%hS) ", __FILE__, __LINE__, __FUNCTION__); \ + DbgPrint _x_; \ + } + +#ifdef ASSERT +#undef ASSERT +#endif + +#ifdef NASSERT +#define ASSERT(x) +#else /* NASSERT */ +#define ASSERT(x) if (!(x)) { Print(MIN_TRACE, ("Assertion "#x" failed at %s:%d\n", __FILE__, __LINE__)); ExitProcess(0); } +#endif /* NASSERT */ + +#else /* DBG */ + +#define Print(_t_, _x_) + +#define ASSERT_IRQL(x) +#define ASSERT(x) + +#endif /* DBG */ + + +#define assert(x) ASSERT(x) +#define assert_irql(x) ASSERT_IRQL(x) + + +#define UNIMPLEMENTED \ + Print(MIN_TRACE, ("is unimplemented, please try again later.\n")); + +#define CHECKPOINT \ + Print(DEBUG_CHECK, ("\n")); + +#define CP CHECKPOINT + + +static char GuidBufferSpace[40]; + +static inline PCHAR PRINT_GUID( const GUID *id ) +{ + CHAR *str; + + if (!id) return "(null)"; + + str = &GuidBufferSpace[0]; + + if (!HIWORD(id)) + { + sprintf( str, "", LOWORD((ULONG)id) ); + } + else + { + sprintf( str, "{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}", + id->Data1, id->Data2, id->Data3, + id->Data4[0], id->Data4[1], id->Data4[2], id->Data4[3], + id->Data4[4], id->Data4[5], id->Data4[6], id->Data4[7] ); + } + return str; +} + +#endif /* __DEBUG_H */ + +/* EOF */ diff --git a/reactos/lib/ole32/include/ole32_main.h b/reactos/lib/ole32/include/ole32_main.h new file mode 100644 index 00000000000..97b000d641d --- /dev/null +++ b/reactos/lib/ole32/include/ole32_main.h @@ -0,0 +1,6 @@ +#ifndef __WINE_OLE32_MAIN_H +#define __WINE_OLE32_MAIN_H + +extern HINSTANCE OLE32_hInstance; + +#endif /* __WINE_OLE32_MAIN_H */ diff --git a/reactos/lib/ole32/include/storage32.h b/reactos/lib/ole32/include/storage32.h new file mode 100644 index 00000000000..5a9589ffa41 --- /dev/null +++ b/reactos/lib/ole32/include/storage32.h @@ -0,0 +1,864 @@ +/* + * Compound Storage (32 bit version) + * + * Implemented using the documentation of the LAOLA project at + * + * (Thanks to Martin Schwartz ) + * + * 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 + +/* + * 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 */ + + /* + * 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] */ + +void StorageImpl_Destroy( + StorageImpl* This); + +HRESULT StorageImpl_Construct( + StorageImpl* This, + HANDLE hFile, + 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__ */ + + +