storage32.c File Reference

#include <assert.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "winnls.h"
#include "winuser.h"
#include "wine/debug.h"
#include "storage32.h"
#include "ole2.h"
#include "winreg.h"
#include "wine/wingdi16.h"
#include "compobj_private.h"

Include dependency graph for storage32.c:

Go to the source code of this file.

Classes
struct	StorageInternalImpl
struct	TransactedDirEntry
struct	TransactedSnapshotImpl
struct	TransactedSharedImpl
struct	BlockChainRun
struct	BlockChainBlock
struct	BlockChainStream
struct	SmallBlockChainStream
struct	IEnumSTATSTGImpl
struct	OLECONVERT_OLESTREAM_DATA
struct	OLECONVERT_ISTORAGE_COMPOBJ
struct	OLECONVERT_ISTORAGE_OLEPRES

Macros
#define	COBJMACROS
#define	NONAMELESSUNION
#define	OLESTREAM_ID   0x501
#define	OLESTREAM_MAX_STR_LEN   255

Typedefs
typedef struct StorageInternalImpl	StorageInternalImpl
typedef struct TransactedDirEntry	TransactedDirEntry
typedef struct TransactedSnapshotImpl	TransactedSnapshotImpl
typedef struct TransactedSharedImpl	TransactedSharedImpl
typedef struct BlockChainBlock	BlockChainBlock

Enumerations
enum	stream_1ole_flags { OleStream_LinkedObject = 0x00000001 , OleStream_Convert = 0x00000004 }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (storage)
static StorageInternalImpl *	StorageInternalImpl_Construct (StorageBaseImpl *, DWORD, DirRef)
static HRESULT	Storage_ConstructTransacted (StorageBaseImpl *, BOOL, StorageBaseImpl **)
static ULONG	BlockChainStream_GetCount (BlockChainStream *This)
static BlockChainStream *	BlockChainStream_Construct (StorageImpl *, ULONG *, DirRef)
static void	BlockChainStream_Destroy (BlockChainStream *)
static HRESULT	BlockChainStream_ReadAt (BlockChainStream *, ULARGE_INTEGER, ULONG, void *, ULONG *)
static HRESULT	BlockChainStream_WriteAt (BlockChainStream *, ULARGE_INTEGER, ULONG, const void *, ULONG *)
static HRESULT	BlockChainStream_Flush (BlockChainStream *)
static ULARGE_INTEGER	BlockChainStream_GetSize (BlockChainStream *)
static BOOL	BlockChainStream_SetSize (BlockChainStream *, ULARGE_INTEGER)
static SmallBlockChainStream *	SmallBlockChainStream_Construct (StorageImpl *, ULONG *, DirRef)
static void	SmallBlockChainStream_Destroy (SmallBlockChainStream *)
static HRESULT	SmallBlockChainStream_ReadAt (SmallBlockChainStream *, ULARGE_INTEGER, ULONG, void *, ULONG *)
static HRESULT	SmallBlockChainStream_WriteAt (SmallBlockChainStream *, ULARGE_INTEGER, ULONG, const void *, ULONG *)
static ULARGE_INTEGER	SmallBlockChainStream_GetSize (SmallBlockChainStream *)
static BOOL	SmallBlockChainStream_SetSize (SmallBlockChainStream *, ULARGE_INTEGER)
static HRESULT	validateSTGM (DWORD stgm)
static DWORD	GetShareModeFromSTGM (DWORD stgm)
static DWORD	GetAccessModeFromSTGM (DWORD stgm)
static DWORD	GetCreationModeFromSTGM (DWORD stgm)
static StorageBaseImpl *	impl_from_IDirectWriterLock (IDirectWriterLock *iface)
static HRESULT WINAPI	directwriterlock_QueryInterface (IDirectWriterLock *iface, REFIID riid, void **obj)
static ULONG WINAPI	directwriterlock_AddRef (IDirectWriterLock *iface)
static ULONG WINAPI	directwriterlock_Release (IDirectWriterLock *iface)
static HRESULT WINAPI	directwriterlock_WaitForWriteAccess (IDirectWriterLock *iface, DWORD timeout)
static HRESULT WINAPI	directwriterlock_ReleaseWriteAccess (IDirectWriterLock *iface)
static HRESULT WINAPI	directwriterlock_HaveWriteAccess (IDirectWriterLock *iface)
static LONG	entryNameCmp (const OLECHAR *name1, const OLECHAR *name2)
static DirRef	findElement (StorageBaseImpl *storage, DirRef storageEntry, const OLECHAR *name, DirEntry *data)
static HRESULT	findTreeParent (StorageBaseImpl *storage, DirRef storageEntry, const OLECHAR *childName, DirEntry *parentData, DirRef *parentEntry, ULONG *relation)
static void	setEntryLink (DirEntry *entry, ULONG relation, DirRef new_target)
static HRESULT	insertIntoTree (StorageBaseImpl *This, DirRef parentStorageIndex, DirRef newEntryIndex)
static HRESULT	removeFromTree (StorageBaseImpl *This, DirRef parentStorageIndex, DirRef deletedIndex)
static IEnumSTATSTGImpl *	impl_from_IEnumSTATSTG (IEnumSTATSTG *iface)
static void	IEnumSTATSTGImpl_Destroy (IEnumSTATSTGImpl *This)
static HRESULT WINAPI	IEnumSTATSTGImpl_QueryInterface (IEnumSTATSTG *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	IEnumSTATSTGImpl_AddRef (IEnumSTATSTG *iface)
static ULONG WINAPI	IEnumSTATSTGImpl_Release (IEnumSTATSTG *iface)
static HRESULT	IEnumSTATSTGImpl_GetNextRef (IEnumSTATSTGImpl *This, DirRef *ref)
static HRESULT WINAPI	IEnumSTATSTGImpl_Next (IEnumSTATSTG *iface, ULONG celt, STATSTG *rgelt, ULONG *pceltFetched)
static HRESULT WINAPI	IEnumSTATSTGImpl_Skip (IEnumSTATSTG *iface, ULONG celt)
static HRESULT WINAPI	IEnumSTATSTGImpl_Reset (IEnumSTATSTG *iface)
static IEnumSTATSTGImpl *	IEnumSTATSTGImpl_Construct (StorageBaseImpl *, DirRef)
static HRESULT WINAPI	IEnumSTATSTGImpl_Clone (IEnumSTATSTG *iface, IEnumSTATSTG **ppenum)
static StorageBaseImpl *	impl_from_IStorage (IStorage *iface)
static HRESULT WINAPI	StorageBaseImpl_QueryInterface (IStorage *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	StorageBaseImpl_AddRef (IStorage *iface)
static ULONG WINAPI	StorageBaseImpl_Release (IStorage *iface)
static HRESULT	StorageBaseImpl_CopyStorageEntryTo (StorageBaseImpl *This, DirRef srcEntry, BOOL skip_storage, BOOL skip_stream, SNB snbExclude, IStorage *pstgDest)
static HRESULT	StorageBaseImpl_CopyChildEntryTo (StorageBaseImpl *This, DirRef srcEntry, BOOL skip_storage, BOOL skip_stream, SNB snbExclude, IStorage *pstgDest)
static BOOL	StorageBaseImpl_IsStreamOpen (StorageBaseImpl *stg, DirRef streamEntry)
static BOOL	StorageBaseImpl_IsStorageOpen (StorageBaseImpl *stg, DirRef storageEntry)
static HRESULT WINAPI	StorageBaseImpl_OpenStream (IStorage *iface, const OLECHAR *pwcsName, void *reserved1, DWORD grfMode, DWORD reserved2, IStream **ppstm)
static HRESULT WINAPI	StorageBaseImpl_OpenStorage (IStorage *iface, const OLECHAR *pwcsName, IStorage *pstgPriority, DWORD grfMode, SNB snbExclude, DWORD reserved, IStorage **ppstg)
static HRESULT WINAPI	StorageBaseImpl_EnumElements (IStorage *iface, DWORD reserved1, void *reserved2, DWORD reserved3, IEnumSTATSTG **ppenum)
static HRESULT WINAPI	StorageBaseImpl_Stat (IStorage *iface, STATSTG *pstatstg, DWORD grfStatFlag)
static HRESULT WINAPI	StorageBaseImpl_RenameElement (IStorage *iface, const OLECHAR *pwcsOldName, const OLECHAR *pwcsNewName)
static HRESULT WINAPI	StorageBaseImpl_CreateStream (IStorage *iface, const OLECHAR *pwcsName, DWORD grfMode, DWORD reserved1, DWORD reserved2, IStream **ppstm)
static HRESULT WINAPI	StorageBaseImpl_SetClass (IStorage *iface, REFCLSID clsid)
static HRESULT WINAPI	StorageBaseImpl_CreateStorage (IStorage *iface, const OLECHAR *pwcsName, DWORD grfMode, DWORD reserved1, DWORD reserved2, IStorage **ppstg)
static HRESULT WINAPI	StorageBaseImpl_CopyTo (IStorage *iface, DWORD ciidExclude, const IID *rgiidExclude, SNB snbExclude, IStorage *pstgDest)
static HRESULT WINAPI	StorageBaseImpl_MoveElementTo (IStorage *iface, const OLECHAR *pwcsName, IStorage *pstgDest, const OLECHAR *pwcsNewName, DWORD grfFlags)
static HRESULT WINAPI	StorageBaseImpl_Commit (IStorage *iface, DWORD grfCommitFlags)
static HRESULT WINAPI	StorageBaseImpl_Revert (IStorage *iface)
static HRESULT	deleteStorageContents (StorageBaseImpl *parentStorage, DirRef indexToDelete, DirEntry entryDataToDelete)
static HRESULT	deleteStreamContents (StorageBaseImpl *parentStorage, DirRef indexToDelete, DirEntry entryDataToDelete)
static HRESULT WINAPI	StorageBaseImpl_DestroyElement (IStorage *iface, const OLECHAR *pwcsName)
static void	StorageBaseImpl_DeleteAll (StorageBaseImpl *stg)
static HRESULT WINAPI	StorageBaseImpl_SetElementTimes (IStorage *iface, const OLECHAR *pwcsName, const FILETIME *pctime, const FILETIME *patime, const FILETIME *pmtime)
static HRESULT WINAPI	StorageBaseImpl_SetStateBits (IStorage *iface, DWORD grfStateBits, DWORD grfMask)
void	StorageBaseImpl_AddStream (StorageBaseImpl *stg, StgStreamImpl *strm)
void	StorageBaseImpl_RemoveStream (StorageBaseImpl *stg, StgStreamImpl *strm)
static HRESULT	StorageBaseImpl_CopyStream (StorageBaseImpl *dst, DirRef dst_entry, StorageBaseImpl *src, DirRef src_entry)
static HRESULT	StorageBaseImpl_DupStorageTree (StorageBaseImpl *dst, DirRef *dst_entry, StorageBaseImpl *src, DirRef src_entry)
static HRESULT	StorageBaseImpl_CopyStorageTree (StorageBaseImpl *dst, DirRef dst_entry, StorageBaseImpl *src, DirRef src_entry)
static HRESULT	StorageBaseImpl_DeleteStorageTree (StorageBaseImpl *This, DirRef entry, BOOL include_siblings)
static HRESULT	StorageImpl_ReadAt (StorageImpl *This, ULARGE_INTEGER offset, void *buffer, ULONG size, ULONG *bytesRead)
static HRESULT	StorageImpl_WriteAt (StorageImpl *This, ULARGE_INTEGER offset, const void *buffer, const ULONG size, ULONG *bytesWritten)
static HRESULT	StorageImpl_LoadFileHeader (StorageImpl *This)
static void	StorageImpl_SaveFileHeader (StorageImpl *This)
static HRESULT	StorageImpl_ReadRawDirEntry (StorageImpl *This, ULONG index, BYTE *buffer)
static HRESULT	StorageImpl_WriteRawDirEntry (StorageImpl *This, ULONG index, const BYTE *buffer)
static HRESULT	StorageImpl_DestroyDirEntry (StorageBaseImpl *base, DirRef index)
static void	UpdateRawDirEntry (BYTE *buffer, const DirEntry *newData)
static HRESULT	StorageImpl_CreateDirEntry (StorageBaseImpl *base, const DirEntry *newData, DirRef *index)
static HRESULT	StorageImpl_ReadDirEntry (StorageImpl *This, DirRef index, DirEntry *buffer)
static HRESULT	StorageImpl_WriteDirEntry (StorageImpl *This, DirRef index, const DirEntry *buffer)
static ULONGLONG	StorageImpl_GetBigBlockOffset (StorageImpl *This, ULONG index)
static HRESULT	StorageImpl_ReadBigBlock (StorageImpl *This, ULONG blockIndex, void *buffer, ULONG *out_read)
static BOOL	StorageImpl_ReadDWordFromBigBlock (StorageImpl *This, ULONG blockIndex, ULONG offset, DWORD *value)
static BOOL	StorageImpl_WriteBigBlock (StorageImpl *This, ULONG blockIndex, const void *buffer)
static BOOL	StorageImpl_WriteDWordToBigBlock (StorageImpl *This, ULONG blockIndex, ULONG offset, DWORD value)
static BlockChainStream *	Storage32Impl_SmallBlocksToBigBlocks (StorageImpl *This, SmallBlockChainStream **ppsbChain)
static SmallBlockChainStream *	Storage32Impl_BigBlocksToSmallBlocks (StorageImpl *This, BlockChainStream **ppbbChain, ULARGE_INTEGER newSize)
static void	Storage32Impl_AddBlockDepot (StorageImpl *This, ULONG blockIndex, ULONG depotIndex)
static ULONG	Storage32Impl_GetExtDepotBlock (StorageImpl *This, ULONG depotIndex)
static void	Storage32Impl_SetExtDepotBlock (StorageImpl *This, ULONG depotIndex, ULONG blockIndex)
static ULONG	Storage32Impl_AddExtBlockDepot (StorageImpl *This)
static HRESULT	StorageImpl_GetNextBlockInChain (StorageImpl *This, ULONG blockIndex, ULONG *nextBlockIndex)
static ULONG	Storage32Impl_GetNextExtendedBlock (StorageImpl *This, ULONG blockIndex)
static void	StorageImpl_SetNextBlockInChain (StorageImpl *This, ULONG blockIndex, ULONG nextBlock)
static ULONG	StorageImpl_GetNextFreeBigBlock (StorageImpl *This)
static void	StorageImpl_FreeBigBlock (StorageImpl *This, ULONG blockIndex)
static HRESULT	StorageImpl_BaseWriteDirEntry (StorageBaseImpl *base, DirRef index, const DirEntry *data)
static HRESULT	StorageImpl_BaseReadDirEntry (StorageBaseImpl *base, DirRef index, DirEntry *data)
static BlockChainStream **	StorageImpl_GetFreeBlockChainCacheEntry (StorageImpl *This)
static BlockChainStream **	StorageImpl_GetCachedBlockChainStream (StorageImpl *This, DirRef index)
static void	StorageImpl_DeleteCachedBlockChainStream (StorageImpl *This, DirRef index)
static HRESULT	StorageImpl_StreamReadAt (StorageBaseImpl *base, DirRef index, ULARGE_INTEGER offset, ULONG size, void *buffer, ULONG *bytesRead)
static HRESULT	StorageImpl_StreamSetSize (StorageBaseImpl *base, DirRef index, ULARGE_INTEGER newsize)
static HRESULT	StorageImpl_StreamWriteAt (StorageBaseImpl *base, DirRef index, ULARGE_INTEGER offset, ULONG size, const void *buffer, ULONG *bytesWritten)
static HRESULT	StorageImpl_StreamLink (StorageBaseImpl *base, DirRef dst, DirRef src)
static HRESULT	StorageImpl_Refresh (StorageImpl *This, BOOL new_object, BOOL create)
static HRESULT	StorageImpl_GetTransactionSig (StorageBaseImpl *base, ULONG *result, BOOL refresh)
static HRESULT	StorageImpl_SetTransactionSig (StorageBaseImpl *base, ULONG value)
static HRESULT	StorageImpl_LockRegion (StorageImpl *This, ULARGE_INTEGER offset, ULARGE_INTEGER cb, DWORD dwLockType, BOOL *supported)
static HRESULT	StorageImpl_UnlockRegion (StorageImpl *This, ULARGE_INTEGER offset, ULARGE_INTEGER cb, DWORD dwLockType)
static HRESULT	StorageImpl_LockRegionSync (StorageImpl *This, ULARGE_INTEGER offset, ULARGE_INTEGER cb, DWORD dwLockType, BOOL *supported)
static HRESULT	StorageImpl_LockTransaction (StorageBaseImpl *base, BOOL write)
static HRESULT	StorageImpl_UnlockTransaction (StorageBaseImpl *base, BOOL write)
static HRESULT	StorageImpl_GetFilename (StorageBaseImpl *iface, LPWSTR *result)
static HRESULT	StorageImpl_CheckLockRange (StorageImpl *This, ULONG start, ULONG end, HRESULT fail_hr)
static HRESULT	StorageImpl_LockOne (StorageImpl *This, ULONG start, ULONG end)
static HRESULT	StorageImpl_GrabLocks (StorageImpl *This, DWORD openFlags)
static HRESULT	StorageImpl_Flush (StorageBaseImpl *storage)
static void	StorageImpl_Invalidate (StorageBaseImpl *iface)
static void	StorageImpl_Destroy (StorageBaseImpl *iface)
static HRESULT	StorageImpl_Construct (HANDLE hFile, LPCOLESTR pwcsName, ILockBytes *pLkbyt, DWORD openFlags, BOOL fileBased, BOOL create, ULONG sector_size, StorageImpl **result)
static void	StorageInternalImpl_Invalidate (StorageBaseImpl *base)
static void	StorageInternalImpl_Destroy (StorageBaseImpl *iface)
static HRESULT	StorageInternalImpl_Flush (StorageBaseImpl *iface)
static HRESULT	StorageInternalImpl_GetFilename (StorageBaseImpl *iface, LPWSTR *result)
static HRESULT	StorageInternalImpl_CreateDirEntry (StorageBaseImpl *base, const DirEntry *newData, DirRef *index)
static HRESULT	StorageInternalImpl_WriteDirEntry (StorageBaseImpl *base, DirRef index, const DirEntry *data)
static HRESULT	StorageInternalImpl_ReadDirEntry (StorageBaseImpl *base, DirRef index, DirEntry *data)
static HRESULT	StorageInternalImpl_DestroyDirEntry (StorageBaseImpl *base, DirRef index)
static HRESULT	StorageInternalImpl_StreamReadAt (StorageBaseImpl *base, DirRef index, ULARGE_INTEGER offset, ULONG size, void *buffer, ULONG *bytesRead)
static HRESULT	StorageInternalImpl_StreamWriteAt (StorageBaseImpl *base, DirRef index, ULARGE_INTEGER offset, ULONG size, const void *buffer, ULONG *bytesWritten)
static HRESULT	StorageInternalImpl_StreamSetSize (StorageBaseImpl *base, DirRef index, ULARGE_INTEGER newsize)
static HRESULT	StorageInternalImpl_StreamLink (StorageBaseImpl *base, DirRef dst, DirRef src)
static HRESULT	StorageInternalImpl_GetTransactionSig (StorageBaseImpl *base, ULONG *result, BOOL refresh)
static HRESULT	StorageInternalImpl_SetTransactionSig (StorageBaseImpl *base, ULONG value)
static HRESULT	StorageInternalImpl_LockTransaction (StorageBaseImpl *base, BOOL write)
static HRESULT	StorageInternalImpl_UnlockTransaction (StorageBaseImpl *base, BOOL write)
static HRESULT WINAPI	StorageInternalImpl_Commit (IStorage *iface, DWORD grfCommitFlags)
static HRESULT WINAPI	StorageInternalImpl_Revert (IStorage *iface)
static DirRef	TransactedSnapshotImpl_FindFreeEntry (TransactedSnapshotImpl *This)
static DirRef	TransactedSnapshotImpl_CreateStubEntry (TransactedSnapshotImpl *This, DirRef parentEntryRef)
static HRESULT	TransactedSnapshotImpl_EnsureReadEntry (TransactedSnapshotImpl *This, DirRef entry)
static HRESULT	TransactedSnapshotImpl_MakeStreamDirty (TransactedSnapshotImpl *This, DirRef entry)
static DirRef	TransactedSnapshotImpl_FindFirstChild (TransactedSnapshotImpl *This, DirRef parent)
static DirRef	TransactedSnapshotImpl_FindNextChild (TransactedSnapshotImpl *This, DirRef current)
static BOOL	TransactedSnapshotImpl_MadeCopy (TransactedSnapshotImpl *This, DirRef entry)
static void	TransactedSnapshotImpl_DestroyTemporaryCopy (TransactedSnapshotImpl *This, DirRef stop)
static HRESULT	TransactedSnapshotImpl_CopyTree (TransactedSnapshotImpl *This)
static HRESULT WINAPI	TransactedSnapshotImpl_Commit (IStorage *iface, DWORD grfCommitFlags)
static HRESULT WINAPI	TransactedSnapshotImpl_Revert (IStorage *iface)
static void	TransactedSnapshotImpl_Invalidate (StorageBaseImpl *This)
static void	TransactedSnapshotImpl_Destroy (StorageBaseImpl *iface)
static HRESULT	TransactedSnapshotImpl_Flush (StorageBaseImpl *iface)
static HRESULT	TransactedSnapshotImpl_GetFilename (StorageBaseImpl *iface, LPWSTR *result)
static HRESULT	TransactedSnapshotImpl_CreateDirEntry (StorageBaseImpl *base, const DirEntry *newData, DirRef *index)
static HRESULT	TransactedSnapshotImpl_WriteDirEntry (StorageBaseImpl *base, DirRef index, const DirEntry *data)
static HRESULT	TransactedSnapshotImpl_ReadDirEntry (StorageBaseImpl *base, DirRef index, DirEntry *data)
static HRESULT	TransactedSnapshotImpl_DestroyDirEntry (StorageBaseImpl *base, DirRef index)
static HRESULT	TransactedSnapshotImpl_StreamReadAt (StorageBaseImpl *base, DirRef index, ULARGE_INTEGER offset, ULONG size, void *buffer, ULONG *bytesRead)
static HRESULT	TransactedSnapshotImpl_StreamWriteAt (StorageBaseImpl *base, DirRef index, ULARGE_INTEGER offset, ULONG size, const void *buffer, ULONG *bytesWritten)
static HRESULT	TransactedSnapshotImpl_StreamSetSize (StorageBaseImpl *base, DirRef index, ULARGE_INTEGER newsize)
static HRESULT	TransactedSnapshotImpl_StreamLink (StorageBaseImpl *base, DirRef dst, DirRef src)
static HRESULT	TransactedSnapshotImpl_GetTransactionSig (StorageBaseImpl *base, ULONG *result, BOOL refresh)
static HRESULT	TransactedSnapshotImpl_SetTransactionSig (StorageBaseImpl *base, ULONG value)
static HRESULT	TransactedSnapshotImpl_LockTransaction (StorageBaseImpl *base, BOOL write)
static HRESULT	TransactedSnapshotImpl_UnlockTransaction (StorageBaseImpl *base, BOOL write)
static HRESULT	TransactedSnapshotImpl_Construct (StorageBaseImpl *parentStorage, TransactedSnapshotImpl **result)
static void	TransactedSharedImpl_Invalidate (StorageBaseImpl *This)
static void	TransactedSharedImpl_Destroy (StorageBaseImpl *iface)
static HRESULT	TransactedSharedImpl_Flush (StorageBaseImpl *iface)
static HRESULT	TransactedSharedImpl_GetFilename (StorageBaseImpl *iface, LPWSTR *result)
static HRESULT	TransactedSharedImpl_CreateDirEntry (StorageBaseImpl *base, const DirEntry *newData, DirRef *index)
static HRESULT	TransactedSharedImpl_WriteDirEntry (StorageBaseImpl *base, DirRef index, const DirEntry *data)
static HRESULT	TransactedSharedImpl_ReadDirEntry (StorageBaseImpl *base, DirRef index, DirEntry *data)
static HRESULT	TransactedSharedImpl_DestroyDirEntry (StorageBaseImpl *base, DirRef index)
static HRESULT	TransactedSharedImpl_StreamReadAt (StorageBaseImpl *base, DirRef index, ULARGE_INTEGER offset, ULONG size, void *buffer, ULONG *bytesRead)
static HRESULT	TransactedSharedImpl_StreamWriteAt (StorageBaseImpl *base, DirRef index, ULARGE_INTEGER offset, ULONG size, const void *buffer, ULONG *bytesWritten)
static HRESULT	TransactedSharedImpl_StreamSetSize (StorageBaseImpl *base, DirRef index, ULARGE_INTEGER newsize)
static HRESULT	TransactedSharedImpl_StreamLink (StorageBaseImpl *base, DirRef dst, DirRef src)
static HRESULT	TransactedSharedImpl_GetTransactionSig (StorageBaseImpl *base, ULONG *result, BOOL refresh)
static HRESULT	TransactedSharedImpl_SetTransactionSig (StorageBaseImpl *base, ULONG value)
static HRESULT	TransactedSharedImpl_LockTransaction (StorageBaseImpl *base, BOOL write)
static HRESULT	TransactedSharedImpl_UnlockTransaction (StorageBaseImpl *base, BOOL write)
static HRESULT WINAPI	TransactedSharedImpl_Commit (IStorage *iface, DWORD grfCommitFlags)
static HRESULT WINAPI	TransactedSharedImpl_Revert (IStorage *iface)
static HRESULT	TransactedSharedImpl_Construct (StorageBaseImpl *parentStorage, TransactedSharedImpl **result)
static HRESULT	Storage_Construct (HANDLE hFile, LPCOLESTR pwcsName, ILockBytes *pLkbyt, DWORD openFlags, BOOL fileBased, BOOL create, ULONG sector_size, StorageBaseImpl **result)
void	StorageUtl_ReadWord (const BYTE *buffer, ULONG offset, WORD *value)
void	StorageUtl_WriteWord (BYTE *buffer, ULONG offset, WORD value)
void	StorageUtl_ReadDWord (const BYTE *buffer, ULONG offset, DWORD *value)
void	StorageUtl_WriteDWord (BYTE *buffer, ULONG offset, DWORD value)
void	StorageUtl_ReadULargeInteger (const BYTE *buffer, ULONG offset, ULARGE_INTEGER *value)
void	StorageUtl_WriteULargeInteger (BYTE *buffer, ULONG offset, const ULARGE_INTEGER *value)
void	StorageUtl_ReadGUID (const BYTE *buffer, ULONG offset, GUID *value)
void	StorageUtl_WriteGUID (BYTE *buffer, ULONG offset, const GUID *value)
void	StorageUtl_CopyDirEntryToSTATSTG (StorageBaseImpl *storage, STATSTG *destination, const DirEntry *source, int statFlags)
static ULONG	BlockChainStream_GetHeadOfChain (BlockChainStream *This)
static HRESULT	BlockChainStream_UpdateIndexCache (BlockChainStream *This)
static ULONG	BlockChainStream_GetSectorOfOffset (BlockChainStream *This, ULONG offset)
static HRESULT	BlockChainStream_GetBlockAtOffset (BlockChainStream *This, ULONG index, BlockChainBlock **block, ULONG *sector, BOOL create)
static BOOL	BlockChainStream_Shrink (BlockChainStream *This, ULARGE_INTEGER newSize)
static BOOL	BlockChainStream_Enlarge (BlockChainStream *This, ULARGE_INTEGER newSize)
static ULONG	SmallBlockChainStream_GetHeadOfChain (SmallBlockChainStream *This)
static HRESULT	SmallBlockChainStream_GetNextBlockInChain (SmallBlockChainStream *This, ULONG blockIndex, ULONG *nextBlockInChain)
static void	SmallBlockChainStream_SetNextBlockInChain (SmallBlockChainStream *This, ULONG blockIndex, ULONG nextBlock)
static void	SmallBlockChainStream_FreeBlock (SmallBlockChainStream *This, ULONG blockIndex)
static ULONG	SmallBlockChainStream_GetNextFreeBlock (SmallBlockChainStream *This)
static BOOL	SmallBlockChainStream_Shrink (SmallBlockChainStream *This, ULARGE_INTEGER newSize)
static BOOL	SmallBlockChainStream_Enlarge (SmallBlockChainStream *This, ULARGE_INTEGER newSize)
static ULONG	SmallBlockChainStream_GetCount (SmallBlockChainStream *This)
static HRESULT	create_storagefile (LPCOLESTR pwcsName, DWORD grfMode, DWORD grfAttrs, STGOPTIONS *pStgOptions, REFIID riid, void **ppstgOpen)
HRESULT WINAPI	StgCreateDocfile (LPCOLESTR pwcsName, DWORD grfMode, DWORD reserved, IStorage **ppstgOpen)
HRESULT WINAPI	StgCreateStorageEx (const WCHAR *pwcsName, DWORD grfMode, DWORD stgfmt, DWORD grfAttrs, STGOPTIONS *pStgOptions, void *reserved, REFIID riid, void **ppObjectOpen)
HRESULT WINAPI	StgCreatePropSetStg (IStorage *pstg, DWORD reserved, IPropertySetStorage **propset)
HRESULT WINAPI	StgOpenStorageEx (const WCHAR *pwcsName, DWORD grfMode, DWORD stgfmt, DWORD grfAttrs, STGOPTIONS *pStgOptions, void *reserved, REFIID riid, void **ppObjectOpen)
HRESULT WINAPI	StgOpenStorage (const OLECHAR *pwcsName, IStorage *pstgPriority, DWORD grfMode, SNB snbExclude, DWORD reserved, IStorage **ppstgOpen)
HRESULT WINAPI	StgCreateDocfileOnILockBytes (ILockBytes *plkbyt, DWORD grfMode, DWORD reserved, IStorage **ppstgOpen)
HRESULT WINAPI	StgOpenStorageOnILockBytes (ILockBytes *plkbyt, IStorage *pstgPriority, DWORD grfMode, SNB snbExclude, DWORD reserved, IStorage **ppstgOpen)
HRESULT WINAPI	StgSetTimes (OLECHAR const *str, FILETIME const *pctime, FILETIME const *patime, FILETIME const *pmtime)
HRESULT WINAPI	StgIsStorageILockBytes (ILockBytes *plkbyt)
HRESULT WINAPI	WriteClassStg (IStorage *pStg, REFCLSID rclsid)
HRESULT WINAPI	ReadClassStg (IStorage *pstg, CLSID *pclsid)
HRESULT WINAPI	OleLoadFromStream (IStream *pStm, REFIID iidInterface, void **ppvObj)
HRESULT WINAPI	OleSaveToStream (IPersistStream *pPStm, IStream *pStm)
HRESULT	STORAGE_CreateOleStream (IStorage *storage, DWORD flags)
static HRESULT	STREAM_WriteString (IStream *stm, LPCWSTR string)
static HRESULT	STREAM_ReadString (IStream *stm, LPWSTR *string)
static HRESULT	STORAGE_WriteCompObj (LPSTORAGE pstg, CLSID *clsid, LPCWSTR lpszUserType, LPCWSTR szClipName, LPCWSTR szProgIDName)
HRESULT WINAPI	WriteFmtUserTypeStg (LPSTORAGE pstg, CLIPFORMAT cf, LPOLESTR lpszUserType)
HRESULT WINAPI	ReadFmtUserTypeStg (LPSTORAGE pstg, CLIPFORMAT *pcf, LPOLESTR *lplpszUserType)
HRESULT WINAPI	StgIsStorageFile (LPCOLESTR fn)
HRESULT WINAPI	WriteClassStm (IStream *pStm, REFCLSID rclsid)
HRESULT WINAPI	ReadClassStm (IStream *pStm, CLSID *pclsid)
static HRESULT	OLECONVERT_LoadOLE10 (LPOLESTREAM pOleStream, OLECONVERT_OLESTREAM_DATA *pData, BOOL bStrem1)
static HRESULT	OLECONVERT_SaveOLE10 (OLECONVERT_OLESTREAM_DATA *pData, LPOLESTREAM pOleStream)
static void	OLECONVERT_GetOLE20FromOLE10 (LPSTORAGE pDestStorage, const BYTE *pBuffer, DWORD nBufferLength)
static DWORD	OLECONVERT_WriteOLE20ToBuffer (LPSTORAGE pStorage, BYTE **pData)
HRESULT	OLECONVERT_CreateCompObjStream (LPSTORAGE pStorage, LPCSTR strOleTypeName)
static void	OLECONVERT_CreateOlePresStream (LPSTORAGE pStorage, DWORD dwExtentX, DWORD dwExtentY, BYTE *pData, DWORD dwDataLength)
static void	OLECONVERT_CreateOle10NativeStream (LPSTORAGE pStorage, const BYTE *pData, DWORD dwDataLength)
static HRESULT	OLECONVERT_GetOLE10ProgID (LPSTORAGE pStorage, char *strProgID, DWORD *dwSize)
static void	OLECONVERT_GetOle10PresData (LPSTORAGE pStorage, OLECONVERT_OLESTREAM_DATA *pOleStreamData)
static void	OLECONVERT_GetOle20PresData (LPSTORAGE pStorage, OLECONVERT_OLESTREAM_DATA *pOleStreamData)
HRESULT WINAPI	OleConvertOLESTREAMToIStorage (LPOLESTREAM pOleStream, LPSTORAGE pstg, const DVTARGETDEVICE *ptd)
HRESULT WINAPI	OleConvertIStorageToOLESTREAM (LPSTORAGE pstg, LPOLESTREAM pOleStream)
HRESULT WINAPI	GetConvertStg (IStorage *stg)
HRESULT WINAPI	SetConvertStg (IStorage *storage, BOOL convert)

Variables
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}
const IPropertySetStorageVtbl	IPropertySetStorage_Vtbl
static const IStorageVtbl	StorageInternalImpl_Vtbl
static const IStorageVtbl	TransactedSnapshotImpl_Vtbl
static const IDirectWriterLockVtbl	DirectWriterLockVtbl
static const IEnumSTATSTGVtbl	IEnumSTATSTGImpl_Vtbl
static const StorageBaseImplVtbl	StorageImpl_BaseVtbl
static const IStorageVtbl	StorageImpl_Vtbl
static const StorageBaseImplVtbl	StorageInternalImpl_BaseVtbl
static const StorageBaseImplVtbl	TransactedSnapshotImpl_BaseVtbl
static const IStorageVtbl	TransactedSharedImpl_Vtbl
static const StorageBaseImplVtbl	TransactedSharedImpl_BaseVtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 39 of file storage32.c.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 40 of file storage32.c.

OLESTREAM_ID

#define OLESTREAM_ID   0x501

Definition at line 9577 of file storage32.c.

OLESTREAM_MAX_STR_LEN

#define OLESTREAM_MAX_STR_LEN   255

Definition at line 9578 of file storage32.c.

Typedef Documentation

BlockChainBlock

typedef struct BlockChainBlock BlockChainBlock

StorageInternalImpl

typedef struct StorageInternalImpl StorageInternalImpl

TransactedDirEntry

typedef struct TransactedDirEntry TransactedDirEntry

TransactedSharedImpl

typedef struct TransactedSharedImpl TransactedSharedImpl

TransactedSnapshotImpl

typedef struct TransactedSnapshotImpl TransactedSnapshotImpl

Enumeration Type Documentation

stream_1ole_flags

enum stream_1ole_flags

Enumerator
OleStream_LinkedObject
OleStream_Convert

Definition at line 10609 of file storage32.c.

                       {
    OleStream_LinkedObject = 0x00000001,
    OleStream_Convert      = 0x00000004
};

Function Documentation

BlockChainStream_Construct()

BlockChainStream * BlockChainStream_Construct ( StorageImpl *  parentStorage, ULONG *  headOfStreamPlaceHolder, DirRef  dirEntry  )

static

Definition at line 7261 of file storage32.c.

{
  BlockChainStream* newStream;
 
  newStream = HeapAlloc(GetProcessHeap(), 0, sizeof(BlockChainStream));
  if(!newStream)
    return NULL;
 
  newStream->parentStorage           = parentStorage;
  newStream->headOfStreamPlaceHolder = headOfStreamPlaceHolder;
  newStream->ownerDirEntry           = dirEntry;
  newStream->indexCache              = NULL;
  newStream->indexCacheLen           = 0;
  newStream->indexCacheSize          = 0;
  newStream->cachedBlocks[0].index = 0xffffffff;
  newStream->cachedBlocks[0].dirty = FALSE;
  newStream->cachedBlocks[1].index = 0xffffffff;
  newStream->cachedBlocks[1].dirty = FALSE;
  newStream->blockToEvict          = 0;
 
  if (FAILED(BlockChainStream_UpdateIndexCache(newStream)))
  {
    HeapFree(GetProcessHeap(), 0, newStream->indexCache);
    HeapFree(GetProcessHeap(), 0, newStream);
    return NULL;
  }
 
  return newStream;
}

Referenced by Storage32Impl_SmallBlocksToBigBlocks(), StorageImpl_GetCachedBlockChainStream(), and StorageImpl_Refresh().

BlockChainStream_Destroy()

void BlockChainStream_Destroy ( BlockChainStream *  This )

static

Definition at line 7311 of file storage32.c.

{
  if (This)
  {
    BlockChainStream_Flush(This);
    HeapFree(GetProcessHeap(), 0, This->indexCache);
  }
  HeapFree(GetProcessHeap(), 0, This);
}

Referenced by Storage32Impl_BigBlocksToSmallBlocks(), Storage32Impl_SmallBlocksToBigBlocks(), StorageImpl_DeleteCachedBlockChainStream(), StorageImpl_Destroy(), StorageImpl_GetCachedBlockChainStream(), StorageImpl_GetFreeBlockChainCacheEntry(), and StorageImpl_Refresh().

BlockChainStream_Enlarge()

static BOOL BlockChainStream_Enlarge ( BlockChainStream *  This, ULARGE_INTEGER  newSize  )

static

Definition at line 7419 of file storage32.c.

{
  ULONG blockIndex, currentBlock;
  ULONG newNumBlocks;
  ULONG oldNumBlocks = 0;
 
  blockIndex = BlockChainStream_GetHeadOfChain(This);
 
  /*
   * Empty chain. Create the head.
   */
  if (blockIndex == BLOCK_END_OF_CHAIN)
  {
    blockIndex = StorageImpl_GetNextFreeBigBlock(This->parentStorage);
    StorageImpl_SetNextBlockInChain(This->parentStorage,
                                      blockIndex,
                                      BLOCK_END_OF_CHAIN);
 
    if (This->headOfStreamPlaceHolder != 0)
    {
      *(This->headOfStreamPlaceHolder) = blockIndex;
    }
    else
    {
      DirEntry chainEntry;
      assert(This->ownerDirEntry != DIRENTRY_NULL);
 
      StorageImpl_ReadDirEntry(
        This->parentStorage,
        This->ownerDirEntry,
        &chainEntry);
 
      chainEntry.startingBlock = blockIndex;
 
      StorageImpl_WriteDirEntry(
        This->parentStorage,
        This->ownerDirEntry,
        &chainEntry);
    }
 
    This->tailIndex = blockIndex;
    This->numBlocks = 1;
  }
 
  /*
   * Figure out how many blocks are needed to contain this stream
   */
  newNumBlocks = newSize.QuadPart / This->parentStorage->bigBlockSize;
 
  if ((newSize.QuadPart % This->parentStorage->bigBlockSize) != 0)
    newNumBlocks++;
 
  /*
   * Go to the current end of chain
   */
  if (This->tailIndex == BLOCK_END_OF_CHAIN)
  {
    currentBlock = blockIndex;
 
    while (blockIndex != BLOCK_END_OF_CHAIN)
    {
      This->numBlocks++;
      currentBlock = blockIndex;
 
      if(FAILED(StorageImpl_GetNextBlockInChain(This->parentStorage, currentBlock,
                        &blockIndex)))
    return FALSE;
    }
 
    This->tailIndex = currentBlock;
  }
 
  currentBlock = This->tailIndex;
  oldNumBlocks = This->numBlocks;
 
  /*
   * Add new blocks to the chain
   */
  if (oldNumBlocks < newNumBlocks)
  {
    while (oldNumBlocks < newNumBlocks)
    {
      blockIndex = StorageImpl_GetNextFreeBigBlock(This->parentStorage);
 
      StorageImpl_SetNextBlockInChain(
    This->parentStorage,
    currentBlock,
    blockIndex);
 
      StorageImpl_SetNextBlockInChain(
        This->parentStorage,
    blockIndex,
    BLOCK_END_OF_CHAIN);
 
      currentBlock = blockIndex;
      oldNumBlocks++;
    }
 
    This->tailIndex = blockIndex;
    This->numBlocks = newNumBlocks;
  }
 
  if (FAILED(BlockChainStream_UpdateIndexCache(This)))
    return FALSE;
 
  return TRUE;
}

Referenced by BlockChainStream_SetSize(), and SmallBlockChainStream_GetNextFreeBlock().

BlockChainStream_Flush()

HRESULT BlockChainStream_Flush ( BlockChainStream *  This )

static

Definition at line 7294 of file storage32.c.

{
  int i;
  if (!This) return S_OK;
  for (i=0; i<2; i++)
  {
    if (This->cachedBlocks[i].dirty)
    {
      if (StorageImpl_WriteBigBlock(This->parentStorage, This->cachedBlocks[i].sector, This->cachedBlocks[i].data))
        This->cachedBlocks[i].dirty = FALSE;
      else
        return STG_E_WRITEFAULT;
    }
  }
  return S_OK;
}

Referenced by BlockChainStream_Destroy(), and StorageImpl_Flush().

BlockChainStream_GetBlockAtOffset()

static HRESULT BlockChainStream_GetBlockAtOffset ( BlockChainStream *  This, ULONG  index, BlockChainBlock **  block, ULONG *  sector, BOOL  create  )

static

Definition at line 7214 of file storage32.c.

{
  BlockChainBlock *result=NULL;
  int i;
 
  for (i=0; i<2; i++)
    if (This->cachedBlocks[i].index == index)
    {
      *sector = This->cachedBlocks[i].sector;
      *block = &This->cachedBlocks[i];
      return S_OK;
    }
 
  *sector = BlockChainStream_GetSectorOfOffset(This, index);
  if (*sector == BLOCK_END_OF_CHAIN)
    return STG_E_DOCFILECORRUPT;
 
  if (create)
  {
    if (This->cachedBlocks[0].index == 0xffffffff)
      result = &This->cachedBlocks[0];
    else if (This->cachedBlocks[1].index == 0xffffffff)
      result = &This->cachedBlocks[1];
    else
    {
      result = &This->cachedBlocks[This->blockToEvict++];
      if (This->blockToEvict == 2)
        This->blockToEvict = 0;
    }
 
    if (result->dirty)
    {
      if (!StorageImpl_WriteBigBlock(This->parentStorage, result->sector, result->data))
        return STG_E_WRITEFAULT;
      result->dirty = FALSE;
    }
 
    result->read = FALSE;
    result->index = index;
    result->sector = *sector;
  }
 
  *block = result;
  return S_OK;
}

Referenced by BlockChainStream_ReadAt(), and BlockChainStream_WriteAt().

BlockChainStream_GetCount()

static ULONG BlockChainStream_GetCount ( BlockChainStream *  This )

inlinestatic

Definition at line 218 of file storage32.c.

{
  return This->numBlocks;
}

Referenced by BlockChainStream_GetSize(), SmallBlockChainStream_GetNextFreeBlock(), StorageImpl_CreateDirEntry(), and StorageImpl_SaveFileHeader().

BlockChainStream_GetHeadOfChain()

static ULONG BlockChainStream_GetHeadOfChain ( BlockChainStream *  This )

static

Definition at line 7085 of file storage32.c.

{
  DirEntry  chainEntry;
  HRESULT   hr;
 
  if (This->headOfStreamPlaceHolder != 0)
    return *(This->headOfStreamPlaceHolder);
 
  if (This->ownerDirEntry != DIRENTRY_NULL)
  {
    hr = StorageImpl_ReadDirEntry(
                      This->parentStorage,
                      This->ownerDirEntry,
                      &chainEntry);
 
    if (SUCCEEDED(hr) && chainEntry.startingBlock < BLOCK_FIRST_SPECIAL)
      return chainEntry.startingBlock;
  }
 
  return BLOCK_END_OF_CHAIN;
}

Referenced by BlockChainStream_Enlarge(), and BlockChainStream_UpdateIndexCache().

BlockChainStream_GetSectorOfOffset()

static ULONG BlockChainStream_GetSectorOfOffset ( BlockChainStream *  This, ULONG  offset  )

static

Definition at line 7185 of file storage32.c.

{
  ULONG min_offset = 0, max_offset = This->numBlocks-1;
  ULONG min_run = 0, max_run = This->indexCacheLen-1;
 
  if (offset >= This->numBlocks)
    return BLOCK_END_OF_CHAIN;
 
  while (min_run < max_run)
  {
    ULONG run_to_check = min_run + (offset - min_offset) * (max_run - min_run) / (max_offset - min_offset);
    if (offset < This->indexCache[run_to_check].firstOffset)
    {
      max_offset = This->indexCache[run_to_check].firstOffset-1;
      max_run = run_to_check-1;
    }
    else if (offset > This->indexCache[run_to_check].lastOffset)
    {
      min_offset = This->indexCache[run_to_check].lastOffset+1;
      min_run = run_to_check+1;
    }
    else
      /* Block is in this run. */
      min_run = max_run = run_to_check;
  }
 
  return This->indexCache[min_run].firstSector + offset - This->indexCache[min_run].firstOffset;
}

Referenced by BlockChainStream_GetBlockAtOffset(), BlockChainStream_ReadAt(), and BlockChainStream_Shrink().

BlockChainStream_GetSize()

static ULARGE_INTEGER BlockChainStream_GetSize ( BlockChainStream *  This )

static

Definition at line 7535 of file storage32.c.

{
  DirEntry chainEntry;
 
  if(This->headOfStreamPlaceHolder == NULL)
  {
    /*
     * This chain has a directory entry so use the size value from there.
     */
    StorageImpl_ReadDirEntry(
      This->parentStorage,
      This->ownerDirEntry,
      &chainEntry);
 
    return chainEntry.size;
  }
  else
  {
    /*
     * this chain is a chain that does not have a directory entry, figure out the
     * size by making the product number of used blocks times the
     * size of them
     */
    ULARGE_INTEGER result;
    result.QuadPart =
      (ULONGLONG)BlockChainStream_GetCount(This) *
      This->parentStorage->bigBlockSize;
 
    return result;
  }
}

Referenced by BlockChainStream_ReadAt(), BlockChainStream_SetSize(), SmallBlockChainStream_GetNextFreeBlock(), and Storage32Impl_BigBlocksToSmallBlocks().

BlockChainStream_ReadAt()

HRESULT BlockChainStream_ReadAt ( BlockChainStream *  This, ULARGE_INTEGER  offset, ULONG  size, void *  buffer, ULONG *  bytesRead  )

static

Definition at line 7605 of file storage32.c.

{
  ULONG blockNoInSequence = offset.QuadPart / This->parentStorage->bigBlockSize;
  ULONG offsetInBlock     = offset.QuadPart % This->parentStorage->bigBlockSize;
  ULONG bytesToReadInBuffer;
  ULONG blockIndex;
  BYTE* bufferWalker;
  ULARGE_INTEGER stream_size;
  HRESULT hr;
  BlockChainBlock *cachedBlock;
 
  TRACE("(%p)-> %i %p %i %p\n",This, offset.u.LowPart, buffer, size, bytesRead);
 
  /*
   * Find the first block in the stream that contains part of the buffer.
   */
  blockIndex = BlockChainStream_GetSectorOfOffset(This, blockNoInSequence);
 
  *bytesRead   = 0;
 
  stream_size = BlockChainStream_GetSize(This);
  if (stream_size.QuadPart > offset.QuadPart)
    size = min(stream_size.QuadPart - offset.QuadPart, size);
  else
    return S_OK;
 
  /*
   * Start reading the buffer.
   */
  bufferWalker = buffer;
 
  while (size > 0)
  {
    ULARGE_INTEGER ulOffset;
    DWORD bytesReadAt;
 
    /*
     * Calculate how many bytes we can copy from this big block.
     */
    bytesToReadInBuffer =
      min(This->parentStorage->bigBlockSize - offsetInBlock, size);
 
    hr = BlockChainStream_GetBlockAtOffset(This, blockNoInSequence, &cachedBlock, &blockIndex, size == bytesToReadInBuffer);
 
    if (FAILED(hr))
      return hr;
 
    if (!cachedBlock)
    {
      /* Not in cache, and we're going to read past the end of the block. */
      ulOffset.QuadPart = StorageImpl_GetBigBlockOffset(This->parentStorage, blockIndex) +
                               offsetInBlock;
 
      StorageImpl_ReadAt(This->parentStorage,
           ulOffset,
           bufferWalker,
           bytesToReadInBuffer,
           &bytesReadAt);
    }
    else
    {
      if (!cachedBlock->read)
      {
        ULONG read;
        if (FAILED(StorageImpl_ReadBigBlock(This->parentStorage, cachedBlock->sector, cachedBlock->data, &read)) && !read)
          return STG_E_READFAULT;
 
        cachedBlock->read = TRUE;
      }
 
      memcpy(bufferWalker, cachedBlock->data+offsetInBlock, bytesToReadInBuffer);
      bytesReadAt = bytesToReadInBuffer;
    }
 
    blockNoInSequence++;
    bufferWalker += bytesReadAt;
    size         -= bytesReadAt;
    *bytesRead   += bytesReadAt;
    offsetInBlock = 0;  /* There is no offset on the next block */
 
    if (bytesToReadInBuffer != bytesReadAt)
        break;
  }
 
  return S_OK;
}

Referenced by SmallBlockChainStream_GetNextBlockInChain(), SmallBlockChainStream_GetNextFreeBlock(), SmallBlockChainStream_ReadAt(), Storage32Impl_BigBlocksToSmallBlocks(), StorageImpl_ReadRawDirEntry(), and StorageImpl_StreamReadAt().

BlockChainStream_SetSize()

BOOL BlockChainStream_SetSize ( BlockChainStream *  This, ULARGE_INTEGER  newSize  )

static

Definition at line 7577 of file storage32.c.

{
  ULARGE_INTEGER size = BlockChainStream_GetSize(This);
 
  if (newSize.QuadPart == size.QuadPart)
    return TRUE;
 
  if (newSize.QuadPart < size.QuadPart)
  {
    BlockChainStream_Shrink(This, newSize);
  }
  else
  {
    BlockChainStream_Enlarge(This, newSize);
  }
 
  return TRUE;
}

Referenced by SmallBlockChainStream_GetNextFreeBlock(), Storage32Impl_BigBlocksToSmallBlocks(), Storage32Impl_SmallBlocksToBigBlocks(), StorageImpl_CreateDirEntry(), and StorageImpl_StreamSetSize().

BlockChainStream_Shrink()

static BOOL BlockChainStream_Shrink ( BlockChainStream *  This, ULARGE_INTEGER  newSize  )

static

Definition at line 7326 of file storage32.c.

{
  ULONG blockIndex;
  ULONG numBlocks;
  int i;
 
  /*
   * Figure out how many blocks are needed to contain the new size
   */
  numBlocks = newSize.QuadPart / This->parentStorage->bigBlockSize;
 
  if ((newSize.QuadPart % This->parentStorage->bigBlockSize) != 0)
    numBlocks++;
 
  if (numBlocks)
  {
    /*
     * Go to the new end of chain
     */
    blockIndex = BlockChainStream_GetSectorOfOffset(This, numBlocks-1);
 
    /* Mark the new end of chain */
    StorageImpl_SetNextBlockInChain(
      This->parentStorage,
      blockIndex,
      BLOCK_END_OF_CHAIN);
 
    This->tailIndex = blockIndex;
  }
  else
  {
    if (This->headOfStreamPlaceHolder != 0)
    {
      *This->headOfStreamPlaceHolder = BLOCK_END_OF_CHAIN;
    }
    else
    {
      DirEntry chainEntry;
      assert(This->ownerDirEntry != DIRENTRY_NULL);
 
      StorageImpl_ReadDirEntry(
        This->parentStorage,
        This->ownerDirEntry,
        &chainEntry);
 
      chainEntry.startingBlock = BLOCK_END_OF_CHAIN;
 
      StorageImpl_WriteDirEntry(
        This->parentStorage,
        This->ownerDirEntry,
        &chainEntry);
    }
 
    This->tailIndex = BLOCK_END_OF_CHAIN;
  }
 
  This->numBlocks = numBlocks;
 
  /*
   * Mark the extra blocks as free
   */
  while (This->indexCacheLen && This->indexCache[This->indexCacheLen-1].lastOffset >= numBlocks)
  {
    struct BlockChainRun *last_run = &This->indexCache[This->indexCacheLen-1];
    StorageImpl_FreeBigBlock(This->parentStorage,
      last_run->firstSector + last_run->lastOffset - last_run->firstOffset);
    if (last_run->lastOffset == last_run->firstOffset)
      This->indexCacheLen--;
    else
      last_run->lastOffset--;
  }
 
  /*
   * Reset the last accessed block cache.
   */
  for (i=0; i<2; i++)
  {
    if (This->cachedBlocks[i].index >= numBlocks)
    {
      This->cachedBlocks[i].index = 0xffffffff;
      This->cachedBlocks[i].dirty = FALSE;
    }
  }
 
  return TRUE;
}

Referenced by BlockChainStream_SetSize().

BlockChainStream_UpdateIndexCache()

static HRESULT BlockChainStream_UpdateIndexCache ( BlockChainStream *  This )

static

Definition at line 7108 of file storage32.c.

{
  ULONG  next_sector, next_offset;
  HRESULT hr;
  struct BlockChainRun *last_run;
 
  if (This->indexCacheLen == 0)
  {
    last_run = NULL;
    next_offset = 0;
    next_sector = BlockChainStream_GetHeadOfChain(This);
  }
  else
  {
    last_run = &This->indexCache[This->indexCacheLen-1];
    next_offset = last_run->lastOffset+1;
    hr = StorageImpl_GetNextBlockInChain(This->parentStorage,
        last_run->firstSector + last_run->lastOffset - last_run->firstOffset,
        &next_sector);
    if (FAILED(hr)) return hr;
  }
 
  while (next_sector != BLOCK_END_OF_CHAIN)
  {
    if (!last_run || next_sector != last_run->firstSector + next_offset - last_run->firstOffset)
    {
      /* Add the current block to the cache. */
      if (This->indexCacheSize == 0)
      {
        This->indexCache = HeapAlloc(GetProcessHeap(), 0, sizeof(struct BlockChainRun)*16);
        if (!This->indexCache) return E_OUTOFMEMORY;
        This->indexCacheSize = 16;
      }
      else if (This->indexCacheSize == This->indexCacheLen)
      {
        struct BlockChainRun *new_cache;
        ULONG new_size;
 
        new_size = This->indexCacheSize * 2;
        new_cache = HeapAlloc(GetProcessHeap(), 0, sizeof(struct BlockChainRun)*new_size);
        if (!new_cache) return E_OUTOFMEMORY;
        memcpy(new_cache, This->indexCache, sizeof(struct BlockChainRun)*This->indexCacheLen);
 
        HeapFree(GetProcessHeap(), 0, This->indexCache);
        This->indexCache = new_cache;
        This->indexCacheSize = new_size;
      }
 
      This->indexCacheLen++;
      last_run = &This->indexCache[This->indexCacheLen-1];
      last_run->firstSector = next_sector;
      last_run->firstOffset = next_offset;
    }
 
    last_run->lastOffset = next_offset;
 
    /* Find the next block. */
    next_offset++;
    hr = StorageImpl_GetNextBlockInChain(This->parentStorage, next_sector, &next_sector);
    if (FAILED(hr)) return hr;
  }
 
  if (This->indexCacheLen)
  {
    This->tailIndex = last_run->firstSector + last_run->lastOffset - last_run->firstOffset;
    This->numBlocks = last_run->lastOffset+1;
  }
  else
  {
    This->tailIndex = BLOCK_END_OF_CHAIN;
    This->numBlocks = 0;
  }
 
  return S_OK;
}

Referenced by BlockChainStream_Construct(), and BlockChainStream_Enlarge().

BlockChainStream_WriteAt()

HRESULT BlockChainStream_WriteAt ( BlockChainStream *  This, ULARGE_INTEGER  offset, ULONG  size, const void *  buffer, ULONG *  bytesWritten  )

static

Definition at line 7702 of file storage32.c.

{
  ULONG blockNoInSequence = offset.QuadPart / This->parentStorage->bigBlockSize;
  ULONG offsetInBlock     = offset.QuadPart % This->parentStorage->bigBlockSize;
  ULONG bytesToWrite;
  ULONG blockIndex;
  const BYTE* bufferWalker;
  HRESULT hr;
  BlockChainBlock *cachedBlock;
 
  *bytesWritten   = 0;
  bufferWalker = buffer;
 
  while (size > 0)
  {
    ULARGE_INTEGER ulOffset;
    DWORD bytesWrittenAt;
 
    /*
     * Calculate how many bytes we can copy to this big block.
     */
    bytesToWrite =
      min(This->parentStorage->bigBlockSize - offsetInBlock, size);
 
    hr = BlockChainStream_GetBlockAtOffset(This, blockNoInSequence, &cachedBlock, &blockIndex, size == bytesToWrite);
 
    /* BlockChainStream_SetSize should have already been called to ensure we have
     * enough blocks in the chain to write into */
    if (FAILED(hr))
    {
      ERR("not enough blocks in chain to write data\n");
      return hr;
    }
 
    if (!cachedBlock)
    {
      /* Not in cache, and we're going to write past the end of the block. */
      ulOffset.QuadPart = StorageImpl_GetBigBlockOffset(This->parentStorage, blockIndex) +
                               offsetInBlock;
 
      StorageImpl_WriteAt(This->parentStorage,
           ulOffset,
           bufferWalker,
           bytesToWrite,
           &bytesWrittenAt);
    }
    else
    {
      if (!cachedBlock->read && bytesToWrite != This->parentStorage->bigBlockSize)
      {
        ULONG read;
        if (FAILED(StorageImpl_ReadBigBlock(This->parentStorage, cachedBlock->sector, cachedBlock->data, &read)) && !read)
          return STG_E_READFAULT;
      }
 
      memcpy(cachedBlock->data+offsetInBlock, bufferWalker, bytesToWrite);
      bytesWrittenAt = bytesToWrite;
      cachedBlock->read = TRUE;
      cachedBlock->dirty = TRUE;
    }
 
    blockNoInSequence++;
    bufferWalker  += bytesWrittenAt;
    size          -= bytesWrittenAt;
    *bytesWritten += bytesWrittenAt;
    offsetInBlock  = 0;      /* There is no offset on the next block */
 
    if (bytesWrittenAt != bytesToWrite)
      break;
  }
 
  return (size == 0) ? S_OK : STG_E_WRITEFAULT;
}

Referenced by SmallBlockChainStream_GetNextFreeBlock(), SmallBlockChainStream_SetNextBlockInChain(), SmallBlockChainStream_WriteAt(), Storage32Impl_SmallBlocksToBigBlocks(), StorageImpl_StreamWriteAt(), and StorageImpl_WriteRawDirEntry().

create_storagefile()

static HRESULT create_storagefile ( LPCOLESTR  pwcsName, DWORD  grfMode, DWORD  grfAttrs, STGOPTIONS *  pStgOptions, REFIID  riid, void **  ppstgOpen  )

static

Definition at line 8485 of file storage32.c.

{
  StorageBaseImpl* newStorage = 0;
  HANDLE       hFile      = INVALID_HANDLE_VALUE;
  HRESULT        hr         = STG_E_INVALIDFLAG;
  DWORD          shareMode;
  DWORD          accessMode;
  DWORD          creationMode;
  DWORD          fileAttributes;
  WCHAR          tempFileName[MAX_PATH];
 
  if (ppstgOpen == 0)
    return STG_E_INVALIDPOINTER;
 
  if (pStgOptions->ulSectorSize != MIN_BIG_BLOCK_SIZE && pStgOptions->ulSectorSize != MAX_BIG_BLOCK_SIZE)
    return STG_E_INVALIDPARAMETER;
 
  /* if no share mode given then DENY_NONE is the default */
  if (STGM_SHARE_MODE(grfMode) == 0)
      grfMode |= STGM_SHARE_DENY_NONE;
 
  if ( FAILED( validateSTGM(grfMode) ))
    goto end;
 
  /* StgCreateDocFile seems to refuse readonly access, despite MSDN */
  switch(STGM_ACCESS_MODE(grfMode))
  {
  case STGM_WRITE:
  case STGM_READWRITE:
    break;
  default:
    goto end;
  }
 
  /* in direct mode, can only use SHARE_EXCLUSIVE */
  if (!(grfMode & STGM_TRANSACTED) && (STGM_SHARE_MODE(grfMode) != STGM_SHARE_EXCLUSIVE))
    goto end;
 
  /* but in transacted mode, any share mode is valid */
 
  /*
   * Generate a unique name.
   */
  if (pwcsName == 0)
  {
    WCHAR tempPath[MAX_PATH];
    static const WCHAR prefix[] = { 'S', 'T', 'O', 0 };
 
    memset(tempPath, 0, sizeof(tempPath));
    memset(tempFileName, 0, sizeof(tempFileName));
 
    if ((GetTempPathW(MAX_PATH, tempPath)) == 0 )
      tempPath[0] = '.';
 
    if (GetTempFileNameW(tempPath, prefix, 0, tempFileName) != 0)
      pwcsName = tempFileName;
    else
    {
      hr = STG_E_INSUFFICIENTMEMORY;
      goto end;
    }
 
    creationMode = TRUNCATE_EXISTING;
  }
  else
  {
    creationMode = GetCreationModeFromSTGM(grfMode);
  }
 
  /*
   * Interpret the STGM value grfMode
   */
  shareMode    = GetShareModeFromSTGM(grfMode);
  accessMode   = GetAccessModeFromSTGM(grfMode);
 
  if (grfMode & STGM_DELETEONRELEASE)
    fileAttributes = FILE_FLAG_RANDOM_ACCESS | FILE_FLAG_DELETE_ON_CLOSE;
  else
    fileAttributes = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS;
 
  *ppstgOpen = 0;
 
  hFile = CreateFileW(pwcsName,
                        accessMode,
                        shareMode,
                        NULL,
                        creationMode,
                        fileAttributes,
                        0);
 
  if (hFile == INVALID_HANDLE_VALUE)
  {
    if(GetLastError() == ERROR_FILE_EXISTS)
      hr = STG_E_FILEALREADYEXISTS;
    else
      hr = E_FAIL;
    goto end;
  }
 
  /*
   * Allocate and initialize the new IStorage object.
   */
  hr = Storage_Construct(
         hFile,
        pwcsName,
         NULL,
         grfMode,
         TRUE,
         TRUE,
         pStgOptions->ulSectorSize,
         &newStorage);
 
  if (FAILED(hr))
  {
    goto end;
  }
 
  hr = IStorage_QueryInterface(&newStorage->IStorage_iface, riid, ppstgOpen);
  IStorage_Release(&newStorage->IStorage_iface);
 
end:
  TRACE("<-- %p  r = %08x\n", *ppstgOpen, hr);
 
  return hr;
}

Referenced by StgCreateDocfile(), and StgCreateStorageEx().

deleteStorageContents()

static HRESULT deleteStorageContents ( StorageBaseImpl *  parentStorage, DirRef  indexToDelete, DirEntry  entryDataToDelete  )

static

Definition at line 2426 of file storage32.c.

{
  IEnumSTATSTG *elements     = 0;
  IStorage   *childStorage = 0;
  STATSTG      currentElement;
  HRESULT      hr;
  HRESULT      destroyHr = S_OK;
  StorageInternalImpl *stg, *stg2;
 
  TRACE("%p,%d\n", parentStorage, indexToDelete);
 
  /* Invalidate any open storage objects. */
  LIST_FOR_EACH_ENTRY_SAFE(stg, stg2, &parentStorage->storageHead, StorageInternalImpl, ParentListEntry)
  {
    if (stg->base.storageDirEntry == indexToDelete)
    {
      StorageBaseImpl_Invalidate(&stg->base);
    }
  }
 
  /*
   * Open the storage and enumerate it
   */
  hr = IStorage_OpenStorage(
        &parentStorage->IStorage_iface,
        entryDataToDelete.name,
        0,
        STGM_WRITE | STGM_SHARE_EXCLUSIVE,
        0,
        0,
        &childStorage);
 
  if (hr != S_OK)
  {
    TRACE("<-- %08x\n", hr);
    return hr;
  }
 
  /*
   * Enumerate the elements
   */
  hr = IStorage_EnumElements(childStorage, 0, 0, 0, &elements);
  if (FAILED(hr))
  {
    IStorage_Release(childStorage);
    TRACE("<-- %08x\n", hr);
    return hr;
  }
 
  do
  {
    /*
     * Obtain the next element
     */
    hr = IEnumSTATSTG_Next(elements, 1, &currentElement, NULL);
    if (hr==S_OK)
    {
      destroyHr = IStorage_DestroyElement(childStorage, currentElement.pwcsName);
 
      CoTaskMemFree(currentElement.pwcsName);
    }
 
    /*
     * We need to Reset the enumeration every time because we delete elements
     * and the enumeration could be invalid
     */
    IEnumSTATSTG_Reset(elements);
 
  } while ((hr == S_OK) && (destroyHr == S_OK));
 
  IStorage_Release(childStorage);
  IEnumSTATSTG_Release(elements);
 
  TRACE("%08x\n", hr);
  return destroyHr;
}

Referenced by StorageBaseImpl_DestroyElement().

deleteStreamContents()

static HRESULT deleteStreamContents ( StorageBaseImpl *  parentStorage, DirRef  indexToDelete, DirEntry  entryDataToDelete  )

static

Definition at line 2513 of file storage32.c.

{
  IStream      *pis;
  HRESULT        hr;
  ULARGE_INTEGER size;
  StgStreamImpl *strm, *strm2;
 
  /* Invalidate any open stream objects. */
  LIST_FOR_EACH_ENTRY_SAFE(strm, strm2, &parentStorage->strmHead, StgStreamImpl, StrmListEntry)
  {
    if (strm->dirEntry == indexToDelete)
    {
      TRACE("Stream deleted %p\n", strm);
      strm->parentStorage = NULL;
      list_remove(&strm->StrmListEntry);
    }
  }
 
  size.u.HighPart = 0;
  size.u.LowPart = 0;
 
  hr = IStorage_OpenStream(&parentStorage->IStorage_iface,
        entryDataToDelete.name, NULL, STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, &pis);
 
  if (hr!=S_OK)
  {
    TRACE("<-- %08x\n", hr);
    return(hr);
  }
 
  /*
   * Zap the stream
   */
  hr = IStream_SetSize(pis, size);
 
  if(hr != S_OK)
  {
    TRACE("<-- %08x\n", hr);
    return hr;
  }
 
  /*
   * Release the stream object.
   */
  IStream_Release(pis);
  TRACE("<-- %08x\n", hr);
  return S_OK;
}

Referenced by StorageBaseImpl_DestroyElement().

directwriterlock_AddRef()

static ULONG WINAPI directwriterlock_AddRef ( IDirectWriterLock *  iface )

static

Definition at line 451 of file storage32.c.

{
  StorageBaseImpl *This = impl_from_IDirectWriterLock(iface);
  return IStorage_AddRef(&This->IStorage_iface);
}

directwriterlock_HaveWriteAccess()

static HRESULT WINAPI directwriterlock_HaveWriteAccess ( IDirectWriterLock *  iface )

static

Definition at line 477 of file storage32.c.

{
  StorageBaseImpl *This = impl_from_IDirectWriterLock(iface);
  FIXME("(%p): stub\n", This);
  return E_NOTIMPL;
}

directwriterlock_QueryInterface()

static HRESULT WINAPI directwriterlock_QueryInterface ( IDirectWriterLock *  iface, REFIID  riid, void **  obj  )

static

Definition at line 445 of file storage32.c.

{
  StorageBaseImpl *This = impl_from_IDirectWriterLock(iface);
  return IStorage_QueryInterface(&This->IStorage_iface, riid, obj);
}

directwriterlock_Release()

static ULONG WINAPI directwriterlock_Release ( IDirectWriterLock *  iface )

static

Definition at line 457 of file storage32.c.

{
  StorageBaseImpl *This = impl_from_IDirectWriterLock(iface);
  return IStorage_Release(&This->IStorage_iface);
}

directwriterlock_ReleaseWriteAccess()

static HRESULT WINAPI directwriterlock_ReleaseWriteAccess ( IDirectWriterLock *  iface )

static

Definition at line 470 of file storage32.c.

{
  StorageBaseImpl *This = impl_from_IDirectWriterLock(iface);
  FIXME("(%p): stub\n", This);
  return E_NOTIMPL;
}

directwriterlock_WaitForWriteAccess()

static HRESULT WINAPI directwriterlock_WaitForWriteAccess ( IDirectWriterLock *  iface, DWORD  timeout  )

static

Definition at line 463 of file storage32.c.

{
  StorageBaseImpl *This = impl_from_IDirectWriterLock(iface);
  FIXME("(%p)->(%d): stub\n", This, timeout);
  return E_NOTIMPL;
}

entryNameCmp()

static LONG entryNameCmp ( const OLECHAR *  name1, const OLECHAR *  name2  )

static

Definition at line 510 of file storage32.c.

{
  LONG diff      = lstrlenW(name1) - lstrlenW(name2);
 
  while (diff == 0 && *name1 != 0)
  {
    /*
     * We compare the string themselves only when they are of the same length
     */
    diff = towupper(*name1++) - towupper(*name2++);
  }
 
  return diff;
}

Referenced by findElement(), findTreeParent(), IEnumSTATSTGImpl_GetNextRef(), and insertIntoTree().

findElement()

static DirRef findElement ( StorageBaseImpl *  storage, DirRef  storageEntry, const OLECHAR *  name, DirEntry *  data  )

static

Definition at line 533 of file storage32.c.

{
  DirRef currentEntry;
 
  /* Read the storage entry to find the root of the tree. */
  StorageBaseImpl_ReadDirEntry(storage, storageEntry, data);
 
  currentEntry = data->dirRootEntry;
 
  while (currentEntry != DIRENTRY_NULL)
  {
    LONG cmp;
 
    StorageBaseImpl_ReadDirEntry(storage, currentEntry, data);
 
    cmp = entryNameCmp(name, data->name);
 
    if (cmp == 0)
      /* found it */
      break;
 
    else if (cmp < 0)
      currentEntry = data->leftChild;
 
    else if (cmp > 0)
      currentEntry = data->rightChild;
  }
 
  return currentEntry;
}

Referenced by StorageBaseImpl_CreateStorage(), StorageBaseImpl_CreateStream(), StorageBaseImpl_DestroyElement(), StorageBaseImpl_OpenStorage(), StorageBaseImpl_OpenStream(), and StorageBaseImpl_RenameElement().

findTreeParent()

static HRESULT findTreeParent ( StorageBaseImpl *  storage, DirRef  storageEntry, const OLECHAR *  childName, DirEntry *  parentData, DirRef *  parentEntry, ULONG *  relation  )

static

Definition at line 574 of file storage32.c.

{
  DirRef childEntry;
  DirEntry childData;
 
  /* Read the storage entry to find the root of the tree. */
  StorageBaseImpl_ReadDirEntry(storage, storageEntry, parentData);
 
  *parentEntry = storageEntry;
  *relation = DIRENTRY_RELATION_DIR;
 
  childEntry = parentData->dirRootEntry;
 
  while (childEntry != DIRENTRY_NULL)
  {
    LONG cmp;
 
    StorageBaseImpl_ReadDirEntry(storage, childEntry, &childData);
 
    cmp = entryNameCmp(childName, childData.name);
 
    if (cmp == 0)
      /* found it */
      break;
 
    else if (cmp < 0)
    {
      *parentData = childData;
      *parentEntry = childEntry;
      *relation = DIRENTRY_RELATION_PREVIOUS;
 
      childEntry = parentData->leftChild;
    }
 
    else if (cmp > 0)
    {
      *parentData = childData;
      *parentEntry = childEntry;
      *relation = DIRENTRY_RELATION_NEXT;
 
      childEntry = parentData->rightChild;
    }
  }
 
  if (childEntry == DIRENTRY_NULL)
    return STG_E_FILENOTFOUND;
  else
    return S_OK;
}

Referenced by removeFromTree().

GetAccessModeFromSTGM()

static DWORD GetAccessModeFromSTGM ( DWORD  stgm )

static

Definition at line 397 of file storage32.c.

{
  switch (STGM_ACCESS_MODE(stgm))
  {
  case STGM_READ:
    return GENERIC_READ;
  case STGM_WRITE:
  case STGM_READWRITE:
    return GENERIC_READ | GENERIC_WRITE;
  }
  ERR("Invalid access mode!\n");
  assert(0);
  return 0;
}

Referenced by create_storagefile(), and StgOpenStorage().

GetConvertStg()

HRESULT WINAPI GetConvertStg

(

IStorage *

stg

)

Definition at line 10617 of file storage32.c.

{
    static const WCHAR stream_1oleW[] = {1,'O','l','e',0};
    static const DWORD version_magic = 0x02000001;
    DWORD header[2];
    IStream *stream;
    HRESULT hr;
 
    TRACE("%p\n", stg);
 
    if (!stg) return E_INVALIDARG;
 
    hr = IStorage_OpenStream(stg, stream_1oleW, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stream);
    if (FAILED(hr)) return hr;
 
    hr = IStream_Read(stream, header, sizeof(header), NULL);
    IStream_Release(stream);
    if (FAILED(hr)) return hr;
 
    if (header[0] != version_magic)
    {
        ERR("got wrong version magic for 1Ole stream, 0x%08x\n", header[0]);
        return E_FAIL;
    }
 
    return header[1] & OleStream_Convert ? S_OK : S_FALSE;
}

Referenced by test_convert().

GetCreationModeFromSTGM()

static DWORD GetCreationModeFromSTGM ( DWORD  stgm )

static

Definition at line 418 of file storage32.c.

{
  switch(STGM_CREATE_MODE(stgm))
  {
  case STGM_CREATE:
    return CREATE_ALWAYS;
  case STGM_CONVERT:
    FIXME("STGM_CONVERT not implemented!\n");
    return CREATE_NEW;
  case STGM_FAILIFTHERE:
    return CREATE_NEW;
  }
  ERR("Invalid create mode!\n");
  assert(0);
  return 0;
}

Referenced by create_storagefile().

GetShareModeFromSTGM()

static DWORD GetShareModeFromSTGM ( DWORD  stgm )

static

Definition at line 371 of file storage32.c.

{
  switch (STGM_SHARE_MODE(stgm))
  {
  case 0:
    assert(stgm & STGM_TRANSACTED);
    /* fall-through */
  case STGM_SHARE_DENY_NONE:
    return FILE_SHARE_READ | FILE_SHARE_WRITE;
  case STGM_SHARE_DENY_READ:
    return FILE_SHARE_WRITE;
  case STGM_SHARE_DENY_WRITE:
  case STGM_SHARE_EXCLUSIVE:
    return FILE_SHARE_READ;
  }
  ERR("Invalid share mode!\n");
  assert(0);
  return 0;
}

Referenced by create_storagefile(), and StgOpenStorage().

IEnumSTATSTGImpl_AddRef()

static ULONG WINAPI IEnumSTATSTGImpl_AddRef ( IEnumSTATSTG *  iface )

static

Definition at line 930 of file storage32.c.

{
  IEnumSTATSTGImpl* const This = impl_from_IEnumSTATSTG(iface);
  return InterlockedIncrement(&This->ref);
}

IEnumSTATSTGImpl_Clone()

static HRESULT WINAPI IEnumSTATSTGImpl_Clone ( IEnumSTATSTG *  iface, IEnumSTATSTG **  ppenum  )

static

Definition at line 1136 of file storage32.c.

{
  IEnumSTATSTGImpl* const This = impl_from_IEnumSTATSTG(iface);
  IEnumSTATSTGImpl* newClone;
 
  TRACE("%p,%p\n", iface, ppenum);
 
  if (This->parentStorage->reverted)
  {
    TRACE("<-- STG_E_REVERTED\n");
    return STG_E_REVERTED;
  }
 
  if (ppenum==0)
    return E_INVALIDARG;
 
  newClone = IEnumSTATSTGImpl_Construct(This->parentStorage,
               This->storageDirEntry);
  if (!newClone)
  {
    *ppenum = NULL;
    return E_OUTOFMEMORY;
  }
 
  /*
   * The new clone enumeration must point to the same current node as
   * the old one.
   */
  memcpy(newClone->name, This->name, sizeof(newClone->name));
 
  *ppenum = &newClone->IEnumSTATSTG_iface;
 
  return S_OK;
}

IEnumSTATSTGImpl_Construct()

static IEnumSTATSTGImpl * IEnumSTATSTGImpl_Construct ( StorageBaseImpl *  parentStorage, DirRef  storageDirEntry  )

static

Definition at line 1187 of file storage32.c.

{
  IEnumSTATSTGImpl* newEnumeration;
 
  newEnumeration = HeapAlloc(GetProcessHeap(), 0, sizeof(IEnumSTATSTGImpl));
 
  if (newEnumeration)
  {
    newEnumeration->IEnumSTATSTG_iface.lpVtbl = &IEnumSTATSTGImpl_Vtbl;
    newEnumeration->ref = 1;
    newEnumeration->name[0] = 0;
 
    /*
     * We want to nail-down the reference to the storage in case the
     * enumeration out-lives the storage in the client application.
     */
    newEnumeration->parentStorage = parentStorage;
    IStorage_AddRef(&newEnumeration->parentStorage->IStorage_iface);
 
    newEnumeration->storageDirEntry = storageDirEntry;
  }
 
  return newEnumeration;
}

Referenced by IEnumSTATSTGImpl_Clone(), and StorageBaseImpl_EnumElements().

IEnumSTATSTGImpl_Destroy()

static void IEnumSTATSTGImpl_Destroy ( IEnumSTATSTGImpl *  This )

static

Definition at line 897 of file storage32.c.

{
  IStorage_Release(&This->parentStorage->IStorage_iface);
  HeapFree(GetProcessHeap(), 0, This);
}

Referenced by IEnumSTATSTGImpl_Release().

IEnumSTATSTGImpl_GetNextRef()

static HRESULT IEnumSTATSTGImpl_GetNextRef ( IEnumSTATSTGImpl *  This, DirRef *  ref  )

static

Definition at line 954 of file storage32.c.

{
  DirRef result = DIRENTRY_NULL;
  DirRef searchNode;
  DirEntry entry;
  HRESULT hr;
  WCHAR result_name[DIRENTRY_NAME_MAX_LEN];
 
  TRACE("%p,%p\n", This, ref);
 
  hr = StorageBaseImpl_ReadDirEntry(This->parentStorage,
    This->parentStorage->storageDirEntry, &entry);
  searchNode = entry.dirRootEntry;
 
  while (SUCCEEDED(hr) && searchNode != DIRENTRY_NULL)
  {
    hr = StorageBaseImpl_ReadDirEntry(This->parentStorage, searchNode, &entry);
 
    if (SUCCEEDED(hr))
    {
      LONG diff = entryNameCmp( entry.name, This->name);
 
      if (diff <= 0)
      {
        searchNode = entry.rightChild;
      }
      else
      {
        result = searchNode;
        memcpy(result_name, entry.name, sizeof(result_name));
        searchNode = entry.leftChild;
      }
    }
  }
 
  if (SUCCEEDED(hr))
  {
    *ref = result;
    if (result != DIRENTRY_NULL)
      memcpy(This->name, result_name, sizeof(result_name));
  }
 
  TRACE("<-- %08x\n", hr);
  return hr;
}

Referenced by IEnumSTATSTGImpl_Next(), and IEnumSTATSTGImpl_Skip().

IEnumSTATSTGImpl_Next()

static HRESULT WINAPI IEnumSTATSTGImpl_Next ( IEnumSTATSTG *  iface, ULONG  celt, STATSTG *  rgelt, ULONG *  pceltFetched  )

static

Definition at line 1002 of file storage32.c.

{
  IEnumSTATSTGImpl* const This = impl_from_IEnumSTATSTG(iface);
 
  DirEntry    currentEntry;
  STATSTG*    currentReturnStruct = rgelt;
  ULONG       objectFetched       = 0;
  DirRef      currentSearchNode;
  HRESULT     hr=S_OK;
 
  TRACE("%p,%u,%p,%p\n", iface, celt, rgelt, pceltFetched);
 
  if ( (rgelt==0) || ( (celt!=1) && (pceltFetched==0) ) )
    return E_INVALIDARG;
 
  if (This->parentStorage->reverted)
  {
    TRACE("<-- STG_E_REVERTED\n");
    return STG_E_REVERTED;
  }
 
  /*
   * To avoid the special case, get another pointer to a ULONG value if
   * the caller didn't supply one.
   */
  if (pceltFetched==0)
    pceltFetched = &objectFetched;
 
  /*
   * Start the iteration, we will iterate until we hit the end of the
   * linked list or until we hit the number of items to iterate through
   */
  *pceltFetched = 0;
 
  while ( *pceltFetched < celt )
  {
    hr = IEnumSTATSTGImpl_GetNextRef(This, &currentSearchNode);
 
    if (FAILED(hr) || currentSearchNode == DIRENTRY_NULL)
    {
      memset(currentReturnStruct, 0, sizeof(*currentReturnStruct));
      break;
    }
 
    /*
     * Read the entry from the storage.
     */
    hr = StorageBaseImpl_ReadDirEntry(This->parentStorage,
      currentSearchNode,
      &currentEntry);
    if (FAILED(hr)) break;
 
    /*
     * Copy the information to the return buffer.
     */
    StorageUtl_CopyDirEntryToSTATSTG(This->parentStorage,
      currentReturnStruct,
      &currentEntry,
      STATFLAG_DEFAULT);
 
    /*
     * Step to the next item in the iteration
     */
    (*pceltFetched)++;
    currentReturnStruct++;
  }
 
  if (SUCCEEDED(hr) && *pceltFetched != celt)
    hr = S_FALSE;
 
  TRACE("<-- %08x (asked %u, got %u)\n", hr, celt, *pceltFetched);
  return hr;
}

IEnumSTATSTGImpl_QueryInterface()

static HRESULT WINAPI IEnumSTATSTGImpl_QueryInterface ( IEnumSTATSTG *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 903 of file storage32.c.

{
  IEnumSTATSTGImpl* const This = impl_from_IEnumSTATSTG(iface);
 
  TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), ppvObject);
 
  if (ppvObject==0)
    return E_INVALIDARG;
 
  *ppvObject = 0;
 
  if (IsEqualGUID(&IID_IUnknown, riid) ||
      IsEqualGUID(&IID_IEnumSTATSTG, riid))
  {
    *ppvObject = &This->IEnumSTATSTG_iface;
    IEnumSTATSTG_AddRef(&This->IEnumSTATSTG_iface);
    TRACE("<-- %p\n", *ppvObject);
    return S_OK;
  }
 
  TRACE("<-- E_NOINTERFACE\n");
  return E_NOINTERFACE;
}

IEnumSTATSTGImpl_Release()

static ULONG WINAPI IEnumSTATSTGImpl_Release ( IEnumSTATSTG *  iface )

static

Definition at line 937 of file storage32.c.

{
  IEnumSTATSTGImpl* const This = impl_from_IEnumSTATSTG(iface);
 
  ULONG newRef;
 
  newRef = InterlockedDecrement(&This->ref);
 
  if (newRef==0)
  {
    IEnumSTATSTGImpl_Destroy(This);
  }
 
  return newRef;
}

IEnumSTATSTGImpl_Reset()

static HRESULT WINAPI IEnumSTATSTGImpl_Reset ( IEnumSTATSTG *  iface )

static

Definition at line 1116 of file storage32.c.

{
  IEnumSTATSTGImpl* const This = impl_from_IEnumSTATSTG(iface);
 
  TRACE("%p\n", iface);
 
  if (This->parentStorage->reverted)
  {
    TRACE("<-- STG_E_REVERTED\n");
    return STG_E_REVERTED;
  }
 
  This->name[0] = 0;
 
  return S_OK;
}

IEnumSTATSTGImpl_Skip()

static HRESULT WINAPI IEnumSTATSTGImpl_Skip ( IEnumSTATSTG *  iface, ULONG  celt  )

static

Definition at line 1081 of file storage32.c.

{
  IEnumSTATSTGImpl* const This = impl_from_IEnumSTATSTG(iface);
 
  ULONG       objectFetched = 0;
  DirRef      currentSearchNode;
  HRESULT     hr=S_OK;
 
  TRACE("%p,%u\n", iface, celt);
 
  if (This->parentStorage->reverted)
  {
    TRACE("<-- STG_E_REVERTED\n");
    return STG_E_REVERTED;
  }
 
  while ( (objectFetched < celt) )
  {
    hr = IEnumSTATSTGImpl_GetNextRef(This, &currentSearchNode);
 
    if (FAILED(hr) || currentSearchNode == DIRENTRY_NULL)
      break;
 
    objectFetched++;
  }
 
  if (SUCCEEDED(hr) && objectFetched != celt)
    return S_FALSE;
 
  TRACE("<-- %08x\n", hr);
  return hr;
}

impl_from_IDirectWriterLock()

static StorageBaseImpl * impl_from_IDirectWriterLock ( IDirectWriterLock *  iface )

inlinestatic

Definition at line 440 of file storage32.c.

{
    return CONTAINING_RECORD(iface, StorageBaseImpl, IDirectWriterLock_iface);
}

Referenced by directwriterlock_AddRef(), directwriterlock_HaveWriteAccess(), directwriterlock_QueryInterface(), directwriterlock_Release(), directwriterlock_ReleaseWriteAccess(), and directwriterlock_WaitForWriteAccess().

impl_from_IEnumSTATSTG()

static IEnumSTATSTGImpl * impl_from_IEnumSTATSTG ( IEnumSTATSTG *  iface )

inlinestatic

Definition at line 892 of file storage32.c.

{
  return CONTAINING_RECORD(iface, IEnumSTATSTGImpl, IEnumSTATSTG_iface);
}

Referenced by IEnumSTATSTGImpl_AddRef(), IEnumSTATSTGImpl_Clone(), IEnumSTATSTGImpl_Next(), IEnumSTATSTGImpl_QueryInterface(), IEnumSTATSTGImpl_Release(), IEnumSTATSTGImpl_Reset(), and IEnumSTATSTGImpl_Skip().

impl_from_IStorage()

static StorageBaseImpl * impl_from_IStorage ( IStorage *  iface )

inlinestatic

Definition at line 1219 of file storage32.c.

{
    return CONTAINING_RECORD(iface, StorageBaseImpl, IStorage_iface);
}

Referenced by StorageBaseImpl_AddRef(), StorageBaseImpl_Commit(), StorageBaseImpl_CopyTo(), StorageBaseImpl_CreateStorage(), StorageBaseImpl_CreateStream(), StorageBaseImpl_DestroyElement(), StorageBaseImpl_EnumElements(), StorageBaseImpl_OpenStorage(), StorageBaseImpl_OpenStream(), StorageBaseImpl_QueryInterface(), StorageBaseImpl_Release(), StorageBaseImpl_RenameElement(), StorageBaseImpl_SetClass(), StorageBaseImpl_SetStateBits(), StorageBaseImpl_Stat(), StorageInternalImpl_Commit(), TransactedSharedImpl_Commit(), TransactedSharedImpl_Construct(), TransactedSharedImpl_Revert(), TransactedSnapshotImpl_Commit(), TransactedSnapshotImpl_Construct(), and TransactedSnapshotImpl_Revert().

insertIntoTree()

static HRESULT insertIntoTree ( StorageBaseImpl *  This, DirRef  parentStorageIndex, DirRef  newEntryIndex  )

static

Definition at line 650 of file storage32.c.

{
  DirEntry currentEntry;
  DirEntry newEntry;
 
  /*
   * Read the inserted entry
   */
  StorageBaseImpl_ReadDirEntry(This,
                               newEntryIndex,
                               &newEntry);
 
  /*
   * Read the storage entry
   */
  StorageBaseImpl_ReadDirEntry(This,
                               parentStorageIndex,
                               &currentEntry);
 
  if (currentEntry.dirRootEntry != DIRENTRY_NULL)
  {
    /*
     * The root storage contains some element, therefore, start the research
     * for the appropriate location.
     */
    BOOL found = FALSE;
    DirRef current, next, previous, currentEntryId;
 
    /*
     * Keep a reference to the root of the storage's element tree
     */
    currentEntryId = currentEntry.dirRootEntry;
 
    /*
     * Read
     */
    StorageBaseImpl_ReadDirEntry(This,
                                 currentEntry.dirRootEntry,
                                 &currentEntry);
 
    previous = currentEntry.leftChild;
    next     = currentEntry.rightChild;
    current  = currentEntryId;
 
    while (!found)
    {
      LONG diff = entryNameCmp( newEntry.name, currentEntry.name);
 
      if (diff < 0)
      {
        if (previous != DIRENTRY_NULL)
        {
          StorageBaseImpl_ReadDirEntry(This,
                                       previous,
                                       &currentEntry);
          current = previous;
        }
        else
        {
          currentEntry.leftChild = newEntryIndex;
          StorageBaseImpl_WriteDirEntry(This,
                                        current,
                                        &currentEntry);
          found = TRUE;
        }
      }
      else if (diff > 0)
      {
        if (next != DIRENTRY_NULL)
        {
          StorageBaseImpl_ReadDirEntry(This,
                                       next,
                                       &currentEntry);
          current = next;
        }
        else
        {
          currentEntry.rightChild = newEntryIndex;
          StorageBaseImpl_WriteDirEntry(This,
                                        current,
                                        &currentEntry);
          found = TRUE;
        }
      }
      else
      {
    /*
     * Trying to insert an item with the same name in the
     * subtree structure.
     */
    return STG_E_FILEALREADYEXISTS;
      }
 
      previous = currentEntry.leftChild;
      next     = currentEntry.rightChild;
    }
  }
  else
  {
    /*
     * The storage is empty, make the new entry the root of its element tree
     */
    currentEntry.dirRootEntry = newEntryIndex;
    StorageBaseImpl_WriteDirEntry(This,
                                  parentStorageIndex,
                                  &currentEntry);
  }
 
  return S_OK;
}

Referenced by StorageBaseImpl_CreateStorage(), StorageBaseImpl_CreateStream(), and StorageBaseImpl_RenameElement().

OLECONVERT_CreateCompObjStream()

HRESULT OLECONVERT_CreateCompObjStream	(	LPSTORAGE	pStorage,
		LPCSTR	strOleTypeName
	)

Definition at line 10028 of file storage32.c.

{
    IStream *pStream;
    HRESULT hStorageRes, hRes = S_OK;
    OLECONVERT_ISTORAGE_COMPOBJ IStorageCompObj;
    static const WCHAR wstrStreamName[] = {1,'C', 'o', 'm', 'p', 'O', 'b', 'j', 0};
    WCHAR bufferW[OLESTREAM_MAX_STR_LEN];
 
    static const BYTE pCompObjUnknown1[] = {0x01, 0x00, 0xFE, 0xFF, 0x03, 0x0A, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF};
    static const BYTE pCompObjUnknown2[] = {0xF4, 0x39, 0xB2, 0x71};
 
    /* Initialize the CompObj structure */
    memset(&IStorageCompObj, 0, sizeof(IStorageCompObj));
    memcpy(IStorageCompObj.byUnknown1, pCompObjUnknown1, sizeof(pCompObjUnknown1));
    memcpy(IStorageCompObj.byUnknown2, pCompObjUnknown2, sizeof(pCompObjUnknown2));
 
 
    /*  Create a CompObj stream if it doesn't exist */
    hStorageRes = IStorage_CreateStream(pStorage, wstrStreamName,
        STGM_WRITE  | STGM_SHARE_EXCLUSIVE, 0, 0, &pStream );
    if(hStorageRes == S_OK)
    {
        /* copy the OleTypeName to the compobj struct */
        IStorageCompObj.dwOleTypeNameLength = strlen(strOleTypeName)+1;
        strcpy(IStorageCompObj.strOleTypeName, strOleTypeName);
 
        /* copy the OleTypeName to the compobj struct */
        /* Note: in the test made, these were Identical      */
        IStorageCompObj.dwProgIDNameLength = strlen(strOleTypeName)+1;
        strcpy(IStorageCompObj.strProgIDName, strOleTypeName);
 
        /* Get the CLSID */
        MultiByteToWideChar( CP_ACP, 0, IStorageCompObj.strProgIDName, -1,
                             bufferW, OLESTREAM_MAX_STR_LEN );
        hRes = CLSIDFromProgID(bufferW, &(IStorageCompObj.clsid));
 
        if(hRes == S_OK)
        {
            HKEY hKey;
            LONG hErr;
            /* Get the CLSID Default Name from the Registry */
            hErr = open_classes_key(HKEY_CLASSES_ROOT, bufferW, MAXIMUM_ALLOWED, &hKey);
            if(hErr == ERROR_SUCCESS)
            {
                char strTemp[OLESTREAM_MAX_STR_LEN];
                IStorageCompObj.dwCLSIDNameLength = OLESTREAM_MAX_STR_LEN;
                hErr = RegQueryValueA(hKey, NULL, strTemp, (LONG*) &(IStorageCompObj.dwCLSIDNameLength));
                if(hErr == ERROR_SUCCESS)
                {
                    strcpy(IStorageCompObj.strCLSIDName, strTemp);
                }
                RegCloseKey(hKey);
            }
        }
 
        /* Write CompObj Structure to stream */
        hRes = IStream_Write(pStream, IStorageCompObj.byUnknown1, sizeof(IStorageCompObj.byUnknown1), NULL);
 
        WriteClassStm(pStream,&(IStorageCompObj.clsid));
 
        hRes = IStream_Write(pStream, &(IStorageCompObj.dwCLSIDNameLength), sizeof(IStorageCompObj.dwCLSIDNameLength), NULL);
        if(IStorageCompObj.dwCLSIDNameLength > 0)
        {
            hRes = IStream_Write(pStream, IStorageCompObj.strCLSIDName, IStorageCompObj.dwCLSIDNameLength, NULL);
        }
        hRes = IStream_Write(pStream, &(IStorageCompObj.dwOleTypeNameLength) , sizeof(IStorageCompObj.dwOleTypeNameLength), NULL);
        if(IStorageCompObj.dwOleTypeNameLength > 0)
        {
            hRes = IStream_Write(pStream, IStorageCompObj.strOleTypeName , IStorageCompObj.dwOleTypeNameLength, NULL);
        }
        hRes = IStream_Write(pStream, &(IStorageCompObj.dwProgIDNameLength) , sizeof(IStorageCompObj.dwProgIDNameLength), NULL);
        if(IStorageCompObj.dwProgIDNameLength > 0)
        {
            hRes = IStream_Write(pStream, IStorageCompObj.strProgIDName , IStorageCompObj.dwProgIDNameLength, NULL);
        }
        hRes = IStream_Write(pStream, IStorageCompObj.byUnknown2 , sizeof(IStorageCompObj.byUnknown2), NULL);
        IStream_Release(pStream);
    }
    return hRes;
}

Referenced by OleConvertOLESTREAMToIStorage(), and render_embed_source_hack().

OLECONVERT_CreateOle10NativeStream()

static void OLECONVERT_CreateOle10NativeStream ( LPSTORAGE  pStorage, const BYTE *  pData, DWORD  dwDataLength  )

static

Definition at line 10214 of file storage32.c.

{
    HRESULT hRes;
    IStream *pStream;
    static const WCHAR wstrStreamName[] = {1, 'O', 'l', 'e', '1', '0', 'N', 'a', 't', 'i', 'v', 'e', 0};
 
    /* Create the Ole10Native Stream */
    hRes = IStorage_CreateStream(pStorage, wstrStreamName,
        STGM_CREATE | STGM_WRITE  | STGM_SHARE_EXCLUSIVE, 0, 0, &pStream );
 
    if(hRes == S_OK)
    {
        /* Write info to stream */
        hRes = IStream_Write(pStream, &dwDataLength, sizeof(dwDataLength), NULL);
        hRes = IStream_Write(pStream, pData, dwDataLength, NULL);
        IStream_Release(pStream);
    }
 
}

Referenced by OleConvertOLESTREAMToIStorage().

OLECONVERT_CreateOlePresStream()

static void OLECONVERT_CreateOlePresStream ( LPSTORAGE  pStorage, DWORD  dwExtentX, DWORD  dwExtentY, BYTE *  pData, DWORD  dwDataLength  )

static

Definition at line 10130 of file storage32.c.

{
    HRESULT hRes;
    IStream *pStream;
    static const WCHAR wstrStreamName[] = {2, 'O', 'l', 'e', 'P', 'r', 'e', 's', '0', '0', '0', 0};
    static const BYTE pOlePresStreamHeader[] =
    {
        0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00,
        0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
        0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00
    };
 
    static const BYTE pOlePresStreamHeaderEmpty[] =
    {
        0x00, 0x00, 0x00, 0x00,
        0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
        0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00
    };
 
    /* Create the OlePres000 Stream */
    hRes = IStorage_CreateStream(pStorage, wstrStreamName,
        STGM_CREATE | STGM_WRITE  | STGM_SHARE_EXCLUSIVE, 0, 0, &pStream );
 
    if(hRes == S_OK)
    {
        DWORD nHeaderSize;
        OLECONVERT_ISTORAGE_OLEPRES OlePres;
 
        memset(&OlePres, 0, sizeof(OlePres));
        /* Do we have any metafile data to save */
        if(dwDataLength > 0)
        {
            memcpy(OlePres.byUnknown1, pOlePresStreamHeader, sizeof(pOlePresStreamHeader));
            nHeaderSize = sizeof(pOlePresStreamHeader);
        }
        else
        {
            memcpy(OlePres.byUnknown1, pOlePresStreamHeaderEmpty, sizeof(pOlePresStreamHeaderEmpty));
            nHeaderSize = sizeof(pOlePresStreamHeaderEmpty);
        }
        /* Set width and height of the metafile */
        OlePres.dwExtentX = dwExtentX;
        OlePres.dwExtentY = -dwExtentY;
 
        /* Set Data and Length */
        if(dwDataLength > sizeof(METAFILEPICT16))
        {
            OlePres.dwSize = dwDataLength - sizeof(METAFILEPICT16);
            OlePres.pData = &(pData[8]);
        }
        /* Save OlePres000 Data to Stream */
        hRes = IStream_Write(pStream, OlePres.byUnknown1, nHeaderSize, NULL);
        hRes = IStream_Write(pStream, &(OlePres.dwExtentX), sizeof(OlePres.dwExtentX), NULL);
        hRes = IStream_Write(pStream, &(OlePres.dwExtentY), sizeof(OlePres.dwExtentY), NULL);
        hRes = IStream_Write(pStream, &(OlePres.dwSize), sizeof(OlePres.dwSize), NULL);
        if(OlePres.dwSize > 0)
        {
            hRes = IStream_Write(pStream, OlePres.pData, OlePres.dwSize, NULL);
        }
        IStream_Release(pStream);
    }
}

Referenced by OleConvertOLESTREAMToIStorage().

OLECONVERT_GetOle10PresData()

static void OLECONVERT_GetOle10PresData ( LPSTORAGE  pStorage, OLECONVERT_OLESTREAM_DATA *  pOleStreamData  )

static

Definition at line 10324 of file storage32.c.

{
 
    HRESULT hRes;
    IStream *pStream;
    static const WCHAR wstrStreamName[] = {1, 'O', 'l', 'e', '1', '0', 'N', 'a', 't', 'i', 'v', 'e', 0};
 
    /* Initialize Default data for OLESTREAM */
    pOleStreamData[0].dwOleID = OLESTREAM_ID;
    pOleStreamData[0].dwTypeID = 2;
    pOleStreamData[1].dwOleID = OLESTREAM_ID;
    pOleStreamData[1].dwTypeID = 0;
    pOleStreamData[0].dwMetaFileWidth = 0;
    pOleStreamData[0].dwMetaFileHeight = 0;
    pOleStreamData[0].pData = NULL;
    pOleStreamData[1].pData = NULL;
 
    /* Open Ole10Native Stream */
    hRes = IStorage_OpenStream(pStorage, wstrStreamName, NULL,
        STGM_READ  | STGM_SHARE_EXCLUSIVE, 0, &pStream );
    if(hRes == S_OK)
    {
 
        /* Read Size and Data */
        IStream_Read(pStream, &(pOleStreamData->dwDataLength), sizeof(pOleStreamData->dwDataLength), NULL);
        if(pOleStreamData->dwDataLength > 0)
        {
            pOleStreamData->pData = HeapAlloc(GetProcessHeap(),0,pOleStreamData->dwDataLength);
            IStream_Read(pStream, pOleStreamData->pData, pOleStreamData->dwDataLength, NULL);
        }
        IStream_Release(pStream);
    }
 
}

Referenced by OleConvertIStorageToOLESTREAM().

OLECONVERT_GetOLE10ProgID()

static HRESULT OLECONVERT_GetOLE10ProgID ( LPSTORAGE  pStorage, char *  strProgID, DWORD *  dwSize  )

static

Definition at line 10253 of file storage32.c.

{
    HRESULT hRes;
    IStream *pStream;
    LARGE_INTEGER iSeekPos;
    OLECONVERT_ISTORAGE_COMPOBJ CompObj;
    static const WCHAR wstrStreamName[] = {1,'C', 'o', 'm', 'p', 'O', 'b', 'j', 0};
 
    /* Open the CompObj Stream */
    hRes = IStorage_OpenStream(pStorage, wstrStreamName, NULL,
        STGM_READ  | STGM_SHARE_EXCLUSIVE, 0, &pStream );
    if(hRes == S_OK)
    {
 
        /*Get the OleType from the CompObj Stream */
        iSeekPos.u.LowPart = sizeof(CompObj.byUnknown1) + sizeof(CompObj.clsid);
        iSeekPos.u.HighPart = 0;
 
        IStream_Seek(pStream, iSeekPos, STREAM_SEEK_SET, NULL);
        IStream_Read(pStream, &CompObj.dwCLSIDNameLength, sizeof(CompObj.dwCLSIDNameLength), NULL);
        iSeekPos.u.LowPart = CompObj.dwCLSIDNameLength;
        IStream_Seek(pStream, iSeekPos, STREAM_SEEK_CUR , NULL);
        IStream_Read(pStream, &CompObj.dwOleTypeNameLength, sizeof(CompObj.dwOleTypeNameLength), NULL);
        iSeekPos.u.LowPart = CompObj.dwOleTypeNameLength;
        IStream_Seek(pStream, iSeekPos, STREAM_SEEK_CUR , NULL);
 
        IStream_Read(pStream, dwSize, sizeof(*dwSize), NULL);
        if(*dwSize > 0)
        {
            IStream_Read(pStream, strProgID, *dwSize, NULL);
        }
        IStream_Release(pStream);
    }
    else
    {
        STATSTG stat;
        LPOLESTR wstrProgID;
 
        /* Get the OleType from the registry */
        REFCLSID clsid = &(stat.clsid);
        IStorage_Stat(pStorage, &stat, STATFLAG_NONAME);
        hRes = ProgIDFromCLSID(clsid, &wstrProgID);
        if(hRes == S_OK)
        {
            *dwSize = WideCharToMultiByte(CP_ACP, 0, wstrProgID, -1, strProgID, *dwSize, NULL, FALSE);
            CoTaskMemFree(wstrProgID);
        }
 
    }
    return hRes;
}

Referenced by OleConvertIStorageToOLESTREAM().

OLECONVERT_GetOLE20FromOLE10()

static void OLECONVERT_GetOLE20FromOLE10 ( LPSTORAGE  pDestStorage, const BYTE *  pBuffer, DWORD  nBufferLength  )

static

Definition at line 9919 of file storage32.c.

{
    HRESULT hRes;
    HANDLE hFile;
    IStorage *pTempStorage;
    DWORD dwNumOfBytesWritten;
    WCHAR wstrTempDir[MAX_PATH], wstrTempFile[MAX_PATH];
    static const WCHAR wstrPrefix[] = {'s', 'i', 's', 0};
 
    /* Create a temp File */
    GetTempPathW(MAX_PATH, wstrTempDir);
    GetTempFileNameW(wstrTempDir, wstrPrefix, 0, wstrTempFile);
    hFile = CreateFileW(wstrTempFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
 
    if(hFile != INVALID_HANDLE_VALUE)
    {
        /* Write IStorage Data to File */
        WriteFile(hFile, pBuffer, nBufferLength, &dwNumOfBytesWritten, NULL);
        CloseHandle(hFile);
 
        /* Open and copy temp storage to the Dest Storage */
        hRes = StgOpenStorage(wstrTempFile, NULL, STGM_READ, NULL, 0, &pTempStorage);
        if(hRes == S_OK)
        {
            hRes = IStorage_CopyTo(pTempStorage, 0, NULL, NULL, pDestStorage);
            IStorage_Release(pTempStorage);
        }
        DeleteFileW(wstrTempFile);
    }
}

Referenced by OleConvertOLESTREAMToIStorage().

OLECONVERT_GetOle20PresData()

static void OLECONVERT_GetOle20PresData ( LPSTORAGE  pStorage, OLECONVERT_OLESTREAM_DATA *  pOleStreamData  )

static

Definition at line 10377 of file storage32.c.

{
    HRESULT hRes;
    IStream *pStream;
    OLECONVERT_ISTORAGE_OLEPRES olePress;
    static const WCHAR wstrStreamName[] = {2, 'O', 'l', 'e', 'P', 'r', 'e', 's', '0', '0', '0', 0};
 
    /* Initialize Default data for OLESTREAM */
    pOleStreamData[0].dwOleID = OLESTREAM_ID;
    pOleStreamData[0].dwTypeID = 2;
    pOleStreamData[0].dwMetaFileWidth = 0;
    pOleStreamData[0].dwMetaFileHeight = 0;
    pOleStreamData[0].dwDataLength = OLECONVERT_WriteOLE20ToBuffer(pStorage, &(pOleStreamData[0].pData));
    pOleStreamData[1].dwOleID = OLESTREAM_ID;
    pOleStreamData[1].dwTypeID = 0;
    pOleStreamData[1].dwOleTypeNameLength = 0;
    pOleStreamData[1].strOleTypeName[0] = 0;
    pOleStreamData[1].dwMetaFileWidth = 0;
    pOleStreamData[1].dwMetaFileHeight = 0;
    pOleStreamData[1].pData = NULL;
    pOleStreamData[1].dwDataLength = 0;
 
 
    /* Open OlePress000 stream */
    hRes = IStorage_OpenStream(pStorage, wstrStreamName, NULL,
        STGM_READ  | STGM_SHARE_EXCLUSIVE, 0, &pStream );
    if(hRes == S_OK)
    {
        LARGE_INTEGER iSeekPos;
        METAFILEPICT16 MetaFilePict;
        static const char strMetafilePictName[] = "METAFILEPICT";
 
        /* Set the TypeID for a Metafile */
        pOleStreamData[1].dwTypeID = 5;
 
        /* Set the OleTypeName to Metafile */
        pOleStreamData[1].dwOleTypeNameLength = strlen(strMetafilePictName) +1;
        strcpy(pOleStreamData[1].strOleTypeName, strMetafilePictName);
 
        iSeekPos.u.HighPart = 0;
        iSeekPos.u.LowPart = sizeof(olePress.byUnknown1);
 
        /* Get Presentation Data */
        IStream_Seek(pStream, iSeekPos, STREAM_SEEK_SET, NULL);
        IStream_Read(pStream, &(olePress.dwExtentX), sizeof(olePress.dwExtentX), NULL);
        IStream_Read(pStream, &(olePress.dwExtentY), sizeof(olePress.dwExtentY), NULL);
        IStream_Read(pStream, &(olePress.dwSize), sizeof(olePress.dwSize), NULL);
 
        /*Set width and Height */
        pOleStreamData[1].dwMetaFileWidth = olePress.dwExtentX;
        pOleStreamData[1].dwMetaFileHeight = -olePress.dwExtentY;
        if(olePress.dwSize > 0)
        {
            /* Set Length */
            pOleStreamData[1].dwDataLength  = olePress.dwSize + sizeof(METAFILEPICT16);
 
            /* Set MetaFilePict struct */
            MetaFilePict.mm = 8;
            MetaFilePict.xExt = olePress.dwExtentX;
            MetaFilePict.yExt = olePress.dwExtentY;
            MetaFilePict.hMF = 0;
 
            /* Get Metafile Data */
            pOleStreamData[1].pData = HeapAlloc(GetProcessHeap(),0,pOleStreamData[1].dwDataLength);
            memcpy(pOleStreamData[1].pData, &MetaFilePict, sizeof(MetaFilePict));
            IStream_Read(pStream, &(pOleStreamData[1].pData[sizeof(MetaFilePict)]), pOleStreamData[1].dwDataLength-sizeof(METAFILEPICT16), NULL);
        }
        IStream_Release(pStream);
    }
}

Referenced by OleConvertIStorageToOLESTREAM().

OLECONVERT_LoadOLE10()

static HRESULT OLECONVERT_LoadOLE10 ( LPOLESTREAM  pOleStream, OLECONVERT_OLESTREAM_DATA *  pData, BOOL  bStrem1  )

static

Definition at line 9640 of file storage32.c.

{
    DWORD dwSize;
    HRESULT hRes = S_OK;
    int nTryCnt=0;
    int max_try = 6;
 
    pData->pData = NULL;
    pData->pstrOleObjFileName = NULL;
 
    for( nTryCnt=0;nTryCnt < max_try; nTryCnt++)
    {
    /* Get the OleID */
    dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)&(pData->dwOleID), sizeof(pData->dwOleID));
    if(dwSize != sizeof(pData->dwOleID))
    {
        hRes = CONVERT10_E_OLESTREAM_GET;
    }
    else if(pData->dwOleID != OLESTREAM_ID)
    {
        hRes = CONVERT10_E_OLESTREAM_FMT;
    }
        else
        {
            hRes = S_OK;
            break;
        }
    }
 
    if(hRes == S_OK)
    {
        /* Get the TypeID... more info needed for this field */
        dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)&(pData->dwTypeID), sizeof(pData->dwTypeID));
        if(dwSize != sizeof(pData->dwTypeID))
        {
            hRes = CONVERT10_E_OLESTREAM_GET;
        }
    }
    if(hRes == S_OK)
    {
        if(pData->dwTypeID != 0)
        {
            /* Get the length of the OleTypeName */
            dwSize = pOleStream->lpstbl->Get(pOleStream, (void *) &(pData->dwOleTypeNameLength), sizeof(pData->dwOleTypeNameLength));
            if(dwSize != sizeof(pData->dwOleTypeNameLength))
            {
                hRes = CONVERT10_E_OLESTREAM_GET;
            }
 
            if(hRes == S_OK)
            {
                if(pData->dwOleTypeNameLength > 0)
                {
                    /* Get the OleTypeName */
                    dwSize = pOleStream->lpstbl->Get(pOleStream, pData->strOleTypeName, pData->dwOleTypeNameLength);
                    if(dwSize != pData->dwOleTypeNameLength)
                    {
                        hRes = CONVERT10_E_OLESTREAM_GET;
                    }
                }
            }
            if(bStrem1)
            {
                dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)&(pData->dwOleObjFileNameLength), sizeof(pData->dwOleObjFileNameLength));
                if(dwSize != sizeof(pData->dwOleObjFileNameLength))
                {
                    hRes = CONVERT10_E_OLESTREAM_GET;
                }
            if(hRes == S_OK)
            {
                    if(pData->dwOleObjFileNameLength < 1) /* there is no file name exist */
                        pData->dwOleObjFileNameLength = sizeof(pData->dwOleObjFileNameLength);
                    pData->pstrOleObjFileName = HeapAlloc(GetProcessHeap(), 0, pData->dwOleObjFileNameLength);
                    if(pData->pstrOleObjFileName)
                    {
                        dwSize = pOleStream->lpstbl->Get(pOleStream, pData->pstrOleObjFileName, pData->dwOleObjFileNameLength);
                        if(dwSize != pData->dwOleObjFileNameLength)
                        {
                            hRes = CONVERT10_E_OLESTREAM_GET;
                        }
                    }
                    else
                        hRes = CONVERT10_E_OLESTREAM_GET;
                }
            }
            else
            {
                /* Get the Width of the Metafile */
                dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)&(pData->dwMetaFileWidth), sizeof(pData->dwMetaFileWidth));
                if(dwSize != sizeof(pData->dwMetaFileWidth))
                {
                    hRes = CONVERT10_E_OLESTREAM_GET;
                }
            if(hRes == S_OK)
            {
                /* Get the Height of the Metafile */
                dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)&(pData->dwMetaFileHeight), sizeof(pData->dwMetaFileHeight));
                if(dwSize != sizeof(pData->dwMetaFileHeight))
                {
                    hRes = CONVERT10_E_OLESTREAM_GET;
                }
            }
            }
            if(hRes == S_OK)
            {
                /* Get the Length of the Data */
                dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)&(pData->dwDataLength), sizeof(pData->dwDataLength));
                if(dwSize != sizeof(pData->dwDataLength))
                {
                    hRes = CONVERT10_E_OLESTREAM_GET;
                }
            }
 
            if(hRes == S_OK) /* I don't know what this 8 byte information is. We have to figure out */
            {
                if(!bStrem1) /* if it is a second OLE stream data */
                {
                    pData->dwDataLength -= 8;
                    dwSize = pOleStream->lpstbl->Get(pOleStream, pData->strUnknown, sizeof(pData->strUnknown));
                    if(dwSize != sizeof(pData->strUnknown))
                    {
                        hRes = CONVERT10_E_OLESTREAM_GET;
                    }
                }
            }
            if(hRes == S_OK)
            {
                if(pData->dwDataLength > 0)
                {
                    pData->pData = HeapAlloc(GetProcessHeap(),0,pData->dwDataLength);
 
                    /* Get Data (ex. IStorage, Metafile, or BMP) */
                    if(pData->pData)
                    {
                        dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)pData->pData, pData->dwDataLength);
                        if(dwSize != pData->dwDataLength)
                        {
                            hRes = CONVERT10_E_OLESTREAM_GET;
                        }
                    }
                    else
                    {
                        hRes = CONVERT10_E_OLESTREAM_GET;
                    }
                }
            }
        }
    }
    return hRes;
}

Referenced by OleConvertOLESTREAMToIStorage().

OLECONVERT_SaveOLE10()

static HRESULT OLECONVERT_SaveOLE10 ( OLECONVERT_OLESTREAM_DATA *  pData, LPOLESTREAM  pOleStream  )

static

Definition at line 9808 of file storage32.c.

{
    DWORD dwSize;
    HRESULT hRes = S_OK;
 
 
   /* Set the OleID */
    dwSize = pOleStream->lpstbl->Put(pOleStream, (void *)&(pData->dwOleID), sizeof(pData->dwOleID));
    if(dwSize != sizeof(pData->dwOleID))
    {
        hRes = CONVERT10_E_OLESTREAM_PUT;
    }
 
    if(hRes == S_OK)
    {
        /* Set the TypeID */
        dwSize = pOleStream->lpstbl->Put(pOleStream, (void *)&(pData->dwTypeID), sizeof(pData->dwTypeID));
        if(dwSize != sizeof(pData->dwTypeID))
        {
            hRes = CONVERT10_E_OLESTREAM_PUT;
        }
    }
 
    if(pData->dwOleID == OLESTREAM_ID && pData->dwTypeID != 0 && hRes == S_OK)
    {
        /* Set the Length of the OleTypeName */
        dwSize = pOleStream->lpstbl->Put(pOleStream, (void *)&(pData->dwOleTypeNameLength), sizeof(pData->dwOleTypeNameLength));
        if(dwSize != sizeof(pData->dwOleTypeNameLength))
        {
            hRes = CONVERT10_E_OLESTREAM_PUT;
        }
 
        if(hRes == S_OK)
        {
            if(pData->dwOleTypeNameLength > 0)
            {
                /* Set the OleTypeName */
                dwSize = pOleStream->lpstbl->Put(pOleStream, pData->strOleTypeName, pData->dwOleTypeNameLength);
                if(dwSize != pData->dwOleTypeNameLength)
                {
                    hRes = CONVERT10_E_OLESTREAM_PUT;
                }
            }
        }
 
        if(hRes == S_OK)
        {
            /* Set the width of the Metafile */
            dwSize = pOleStream->lpstbl->Put(pOleStream, (void *)&(pData->dwMetaFileWidth), sizeof(pData->dwMetaFileWidth));
            if(dwSize != sizeof(pData->dwMetaFileWidth))
            {
                hRes = CONVERT10_E_OLESTREAM_PUT;
            }
        }
 
        if(hRes == S_OK)
        {
            /* Set the height of the Metafile */
            dwSize = pOleStream->lpstbl->Put(pOleStream, (void *)&(pData->dwMetaFileHeight), sizeof(pData->dwMetaFileHeight));
            if(dwSize != sizeof(pData->dwMetaFileHeight))
            {
                hRes = CONVERT10_E_OLESTREAM_PUT;
            }
        }
 
        if(hRes == S_OK)
        {
            /* Set the length of the Data */
            dwSize = pOleStream->lpstbl->Put(pOleStream, (void *)&(pData->dwDataLength), sizeof(pData->dwDataLength));
            if(dwSize != sizeof(pData->dwDataLength))
            {
                hRes = CONVERT10_E_OLESTREAM_PUT;
            }
        }
 
        if(hRes == S_OK)
        {
            if(pData->dwDataLength > 0)
            {
                /* Set the Data (eg. IStorage, Metafile, Bitmap) */
                dwSize = pOleStream->lpstbl->Put(pOleStream, (void *)  pData->pData, pData->dwDataLength);
                if(dwSize != pData->dwDataLength)
                {
                    hRes = CONVERT10_E_OLESTREAM_PUT;
                }
            }
        }
    }
    return hRes;
}

Referenced by OleConvertIStorageToOLESTREAM().

OLECONVERT_WriteOLE20ToBuffer()

static DWORD OLECONVERT_WriteOLE20ToBuffer ( LPSTORAGE  pStorage, BYTE **  pData  )

static

Definition at line 9969 of file storage32.c.

{
    HANDLE hFile;
    HRESULT hRes;
    DWORD nDataLength = 0;
    IStorage *pTempStorage;
    WCHAR wstrTempDir[MAX_PATH], wstrTempFile[MAX_PATH];
    static const WCHAR wstrPrefix[] = {'s', 'i', 's', 0};
 
    *pData = NULL;
 
    /* Create temp Storage */
    GetTempPathW(MAX_PATH, wstrTempDir);
    GetTempFileNameW(wstrTempDir, wstrPrefix, 0, wstrTempFile);
    hRes = StgCreateDocfile(wstrTempFile, STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &pTempStorage);
 
    if(hRes == S_OK)
    {
        /* Copy Src Storage to the Temp Storage */
        IStorage_CopyTo(pStorage, 0, NULL, NULL, pTempStorage);
        IStorage_Release(pTempStorage);
 
        /* Open Temp Storage as a file and copy to memory */
        hFile = CreateFileW(wstrTempFile, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
        if(hFile != INVALID_HANDLE_VALUE)
        {
            nDataLength = GetFileSize(hFile, NULL);
            *pData = HeapAlloc(GetProcessHeap(),0,nDataLength);
            ReadFile(hFile, *pData, nDataLength, &nDataLength, 0);
            CloseHandle(hFile);
        }
        DeleteFileW(wstrTempFile);
    }
    return nDataLength;
}

Referenced by OLECONVERT_GetOle20PresData().

OleConvertIStorageToOLESTREAM()

HRESULT WINAPI OleConvertIStorageToOLESTREAM	(	LPSTORAGE	pstg,
		LPOLESTREAM	pOleStream
	)

Definition at line 10551 of file storage32.c.

{
    int i;
    HRESULT hRes = S_OK;
    IStream *pStream;
    OLECONVERT_OLESTREAM_DATA pOleStreamData[2];
    static const WCHAR wstrStreamName[] = {1, 'O', 'l', 'e', '1', '0', 'N', 'a', 't', 'i', 'v', 'e', 0};
 
    TRACE("%p %p\n", pstg, pOleStream);
 
    memset(pOleStreamData, 0, sizeof(pOleStreamData));
 
    if(pstg == NULL || pOleStream == NULL)
    {
        hRes = E_INVALIDARG;
    }
    if(hRes == S_OK)
    {
        /* Get the ProgID */
        pOleStreamData[0].dwOleTypeNameLength = OLESTREAM_MAX_STR_LEN;
        hRes = OLECONVERT_GetOLE10ProgID(pstg, pOleStreamData[0].strOleTypeName, &(pOleStreamData[0].dwOleTypeNameLength));
    }
    if(hRes == S_OK)
    {
        /* Was it originally Ole10 */
        hRes = IStorage_OpenStream(pstg, wstrStreamName, 0, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &pStream);
        if(hRes == S_OK)
        {
            IStream_Release(pStream);
            /* Get Presentation Data for Ole10Native */
            OLECONVERT_GetOle10PresData(pstg, pOleStreamData);
        }
        else
        {
            /* Get Presentation Data (OLE20) */
            OLECONVERT_GetOle20PresData(pstg, pOleStreamData);
        }
 
        /* Save OLESTREAM */
        hRes = OLECONVERT_SaveOLE10(&(pOleStreamData[0]), pOleStream);
        if(hRes == S_OK)
        {
            hRes = OLECONVERT_SaveOLE10(&(pOleStreamData[1]), pOleStream);
        }
 
    }
 
    /* Free allocated memory */
    for(i=0; i < 2; i++)
    {
        HeapFree(GetProcessHeap(),0,pOleStreamData[i].pData);
    }
 
    return hRes;
}

OleConvertOLESTREAMToIStorage()

HRESULT WINAPI OleConvertOLESTREAMToIStorage	(	LPOLESTREAM	pOleStream,
		LPSTORAGE	pstg,
		const DVTARGETDEVICE *	ptd
	)

Definition at line 10460 of file storage32.c.

{
    int i;
    HRESULT hRes=S_OK;
    OLECONVERT_OLESTREAM_DATA pOleStreamData[2];
 
    TRACE("%p %p %p\n", pOleStream, pstg, ptd);
 
    memset(pOleStreamData, 0, sizeof(pOleStreamData));
 
    if(ptd != NULL)
    {
        FIXME("DVTARGETDEVICE is not NULL, unhandled parameter\n");
    }
 
    if(pstg == NULL || pOleStream == NULL)
    {
        hRes = E_INVALIDARG;
    }
 
    if(hRes == S_OK)
    {
        /* Load the OLESTREAM to Memory */
        hRes = OLECONVERT_LoadOLE10(pOleStream, &pOleStreamData[0], TRUE);
    }
 
    if(hRes == S_OK)
    {
        /* Load the OLESTREAM to Memory (part 2)*/
        hRes = OLECONVERT_LoadOLE10(pOleStream, &pOleStreamData[1], FALSE);
    }
 
    if(hRes == S_OK)
    {
 
        if(pOleStreamData[0].dwDataLength > sizeof(STORAGE_magic))
        {
            /* Do we have the IStorage Data in the OLESTREAM */
            if(memcmp(pOleStreamData[0].pData, STORAGE_magic, sizeof(STORAGE_magic)) ==0)
            {
                OLECONVERT_GetOLE20FromOLE10(pstg, pOleStreamData[0].pData, pOleStreamData[0].dwDataLength);
                OLECONVERT_CreateOlePresStream(pstg, pOleStreamData[1].dwMetaFileWidth, pOleStreamData[1].dwMetaFileHeight, pOleStreamData[1].pData, pOleStreamData[1].dwDataLength);
            }
            else
            {
                /* It must be an original OLE 1.0 source */
                OLECONVERT_CreateOle10NativeStream(pstg, pOleStreamData[0].pData, pOleStreamData[0].dwDataLength);
            }
        }
        else
        {
            /* It must be an original OLE 1.0 source */
            OLECONVERT_CreateOle10NativeStream(pstg, pOleStreamData[0].pData, pOleStreamData[0].dwDataLength);
        }
 
        /* Create CompObj Stream if necessary */
        hRes = OLECONVERT_CreateCompObjStream(pstg, pOleStreamData[0].strOleTypeName);
        if(hRes == S_OK)
        {
            /*Create the Ole Stream if necessary */
            STORAGE_CreateOleStream(pstg, 0);
        }
    }
 
 
    /* Free allocated memory */
    for(i=0; i < 2; i++)
    {
        HeapFree(GetProcessHeap(),0,pOleStreamData[i].pData);
        HeapFree(GetProcessHeap(),0,pOleStreamData[i].pstrOleObjFileName);
        pOleStreamData[i].pstrOleObjFileName = NULL;
    }
    return hRes;
}

OleLoadFromStream()

HRESULT WINAPI OleLoadFromStream	(	IStream *	pStm,
		REFIID	iidInterface,
		void **	ppvObj
	)

Definition at line 9129 of file storage32.c.

{
    CLSID   clsid;
    HRESULT res;
    LPPERSISTSTREAM xstm;
 
    TRACE("(%p,%s,%p)\n",pStm,debugstr_guid(iidInterface),ppvObj);
 
    res=ReadClassStm(pStm,&clsid);
    if (FAILED(res))
    return res;
    res=CoCreateInstance(&clsid,NULL,CLSCTX_INPROC_SERVER,iidInterface,ppvObj);
    if (FAILED(res))
    return res;
    res=IUnknown_QueryInterface((IUnknown*)*ppvObj,&IID_IPersistStream,(LPVOID*)&xstm);
    if (FAILED(res)) {
    IUnknown_Release((IUnknown*)*ppvObj);
    return res;
    }
    res=IPersistStream_Load(xstm,pStm);
    IPersistStream_Release(xstm);
    /* FIXME: all refcounts ok at this point? I think they should be:
     *      pStm    : unchanged
     *      ppvObj  : 1
     *      xstm    : 0 (released)
     */
    return res;
}

Referenced by CompositeMonikerImpl_Load(), HlinkClone(), IPersistStream_fnLoad(), and CTrayBandSite::OnLoad().

OleSaveToStream()

HRESULT WINAPI OleSaveToStream	(	IPersistStream *	pPStm,
		IStream *	pStm
	)

Definition at line 9164 of file storage32.c.

{
 
    CLSID clsid;
    HRESULT res;
 
    TRACE("(%p,%p)\n",pPStm,pStm);
 
    res=IPersistStream_GetClassID(pPStm,&clsid);
 
    if (SUCCEEDED(res)){
 
        res=WriteClassStm(pStm,&clsid);
 
        if (SUCCEEDED(res))
 
            res=IPersistStream_Save(pPStm,pStm,TRUE);
    }
 
    TRACE("Finished Save\n");
    return res;
}

Referenced by CompositeMonikerImpl_Save(), HlinkClone(), and IPersistStream_fnSave().

ReadClassStg()

HRESULT WINAPI ReadClassStg	(	IStorage *	pstg,
		CLSID *	pclsid
	)

Definition at line 9103 of file storage32.c.

                                                         {
 
    STATSTG pstatstg;
    HRESULT hRes;
 
    TRACE("(%p, %p)\n", pstg, pclsid);
 
    if(!pstg || !pclsid)
        return E_INVALIDARG;
 
   /*
    * read a STATSTG structure (contains the clsid) from the storage
    */
    hRes=IStorage_Stat(pstg,&pstatstg,STATFLAG_NONAME);
 
    if(SUCCEEDED(hRes))
        *pclsid=pstatstg.clsid;
 
    return hRes;
}

Referenced by DataCache_InitNew(), DataCache_Load(), GetClassFile(), render_embed_source_hack(), and test_writeclassstg().

ReadClassStm()

HRESULT WINAPI ReadClassStm	(	IStream *	pStm,
		CLSID *	pclsid
	)

Definition at line 9548 of file storage32.c.

{
    ULONG nbByte;
    HRESULT res;
 
    TRACE("(%p,%p)\n",pStm,pclsid);
 
    if (!pStm || !pclsid)
        return E_INVALIDARG;
 
    /* clear the output args */
    *pclsid = CLSID_NULL;
 
    res = IStream_Read(pStm, pclsid, sizeof(CLSID), &nbByte);
 
    if (FAILED(res))
        return res;
 
    if (nbByte != sizeof(CLSID))
        return STG_E_READFAULT;
    else
        return S_OK;
}

Referenced by OleLoadFromStream(), ReadFmtUserTypeStg(), and test_ReadClassStm().

ReadFmtUserTypeStg()

HRESULT WINAPI ReadFmtUserTypeStg	(	LPSTORAGE	pstg,
		CLIPFORMAT *	pcf,
		LPOLESTR *	lplpszUserType
	)

Definition at line 9399 of file storage32.c.

{
    HRESULT r;
    IStream *stm = 0;
    static const WCHAR szCompObj[] = { 1, 'C','o','m','p','O','b','j', 0 };
    unsigned char unknown1[12];
    unsigned char unknown2[16];
    DWORD count;
    LPWSTR szProgIDName = NULL, szCLSIDName = NULL, szOleTypeName = NULL;
    CLSID clsid;
 
    TRACE("(%p,%p,%p)\n", pstg, pcf, lplpszUserType);
 
    r = IStorage_OpenStream( pstg, szCompObj, NULL,
                    STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm );
    if( FAILED ( r ) )
    {
        WARN("Failed to open stream r = %08x\n", r);
        return r;
    }
 
    /* read the various parts of the structure */
    r = IStream_Read( stm, unknown1, sizeof(unknown1), &count );
    if( FAILED( r ) || ( count != sizeof(unknown1) ) )
        goto end;
    r = ReadClassStm( stm, &clsid );
    if( FAILED( r ) )
        goto end;
 
    r = STREAM_ReadString( stm, &szCLSIDName );
    if( FAILED( r ) )
        goto end;
 
    r = STREAM_ReadString( stm, &szOleTypeName );
    if( FAILED( r ) )
        goto end;
 
    r = STREAM_ReadString( stm, &szProgIDName );
    if( FAILED( r ) )
        goto end;
 
    r = IStream_Read( stm, unknown2, sizeof(unknown2), &count );
    if( FAILED( r ) || ( count != sizeof(unknown2) ) )
        goto end;
 
    /* ok, success... now we just need to store what we found */
    if( pcf )
        *pcf = RegisterClipboardFormatW( szOleTypeName );
 
    if( lplpszUserType )
    {
        *lplpszUserType = szCLSIDName;
        szCLSIDName = NULL;
    }
 
end:
    CoTaskMemFree( szCLSIDName );
    CoTaskMemFree( szOleTypeName );
    CoTaskMemFree( szProgIDName );
    IStream_Release( stm );
 
    return r;
}

Referenced by OleDoAutoConvert().

removeFromTree()

static HRESULT removeFromTree ( StorageBaseImpl *  This, DirRef  parentStorageIndex, DirRef  deletedIndex  )

static

Definition at line 771 of file storage32.c.

{
  DirEntry   entryToDelete;
  DirEntry   parentEntry;
  DirRef parentEntryRef;
  ULONG typeOfRelation;
  HRESULT hr;
 
  hr = StorageBaseImpl_ReadDirEntry(This, deletedIndex, &entryToDelete);
 
  if (hr != S_OK)
    return hr;
 
  /*
   * Find the element that links to the one we want to delete.
   */
  hr = findTreeParent(This, parentStorageIndex, entryToDelete.name,
    &parentEntry, &parentEntryRef, &typeOfRelation);
 
  if (hr != S_OK)
    return hr;
 
  if (entryToDelete.leftChild != DIRENTRY_NULL)
  {
    /*
     * Replace the deleted entry with its left child
     */
    setEntryLink(&parentEntry, typeOfRelation, entryToDelete.leftChild);
 
    hr = StorageBaseImpl_WriteDirEntry(
            This,
            parentEntryRef,
            &parentEntry);
    if(FAILED(hr))
    {
      return hr;
    }
 
    if (entryToDelete.rightChild != DIRENTRY_NULL)
    {
      /*
       * We need to reinsert the right child somewhere. We already know it and
       * its children are greater than everything in the left tree, so we
       * insert it at the rightmost point in the left tree.
       */
      DirRef newRightChildParent = entryToDelete.leftChild;
      DirEntry newRightChildParentEntry;
 
      do
      {
        hr = StorageBaseImpl_ReadDirEntry(
                This,
                newRightChildParent,
                &newRightChildParentEntry);
        if (FAILED(hr))
        {
          return hr;
        }
 
        if (newRightChildParentEntry.rightChild != DIRENTRY_NULL)
          newRightChildParent = newRightChildParentEntry.rightChild;
      } while (newRightChildParentEntry.rightChild != DIRENTRY_NULL);
 
      newRightChildParentEntry.rightChild = entryToDelete.rightChild;
 
      hr = StorageBaseImpl_WriteDirEntry(
              This,
              newRightChildParent,
              &newRightChildParentEntry);
      if (FAILED(hr))
      {
        return hr;
      }
    }
  }
  else
  {
    /*
     * Replace the deleted entry with its right child
     */
    setEntryLink(&parentEntry, typeOfRelation, entryToDelete.rightChild);
 
    hr = StorageBaseImpl_WriteDirEntry(
            This,
            parentEntryRef,
            &parentEntry);
    if(FAILED(hr))
    {
      return hr;
    }
  }
 
  return hr;
}

Referenced by StorageBaseImpl_DestroyElement(), and StorageBaseImpl_RenameElement().

SetConvertStg()

HRESULT WINAPI SetConvertStg	(	IStorage *	storage,
		BOOL	convert
	)

Definition at line 10648 of file storage32.c.

{
    static const WCHAR stream_1oleW[] = {1,'O','l','e',0};
    DWORD flags = convert ? OleStream_Convert : 0;
    IStream *stream;
    DWORD header[2];
    HRESULT hr;
 
    TRACE("(%p, %d)\n", storage, convert);
 
    hr = IStorage_OpenStream(storage, stream_1oleW, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stream);
    if (FAILED(hr))
    {
        if (hr != STG_E_FILENOTFOUND)
            return hr;
 
        return STORAGE_CreateOleStream(storage, flags);
    }
 
    hr = IStream_Read(stream, header, sizeof(header), NULL);
    if (FAILED(hr))
    {
        IStream_Release(stream);
        return hr;
    }
 
    /* update flag if differs */
    if ((header[1] ^ flags) & OleStream_Convert)
    {
        LARGE_INTEGER pos = {{0}};
 
        if (header[1] & OleStream_Convert)
            flags = header[1] & ~OleStream_Convert;
        else
            flags = header[1] |  OleStream_Convert;
 
        pos.QuadPart = sizeof(DWORD);
        hr = IStream_Seek(stream, pos, STREAM_SEEK_SET, NULL);
        if (FAILED(hr))
        {
            IStream_Release(stream);
            return hr;
        }
 
        hr = IStream_Write(stream, &flags, sizeof(flags), NULL);
    }
 
    IStream_Release(stream);
    return hr;
}

Referenced by OleDoAutoConvert(), test_convert(), and test_OleDoAutoConvert().

setEntryLink()

static void setEntryLink ( DirEntry *  entry, ULONG  relation, DirRef  new_target  )

static

Definition at line 626 of file storage32.c.

{
  switch (relation)
  {
    case DIRENTRY_RELATION_PREVIOUS:
      entry->leftChild = new_target;
      break;
    case DIRENTRY_RELATION_NEXT:
      entry->rightChild = new_target;
      break;
    case DIRENTRY_RELATION_DIR:
      entry->dirRootEntry = new_target;
      break;
    default:
      assert(0);
  }
}

Referenced by removeFromTree().

SmallBlockChainStream_Construct()

SmallBlockChainStream * SmallBlockChainStream_Construct ( StorageImpl *  parentStorage, ULONG *  headOfStreamPlaceHolder, DirRef  dirEntry  )

static

Definition at line 7785 of file storage32.c.

{
  SmallBlockChainStream* newStream;
 
  newStream = HeapAlloc(GetProcessHeap(), 0, sizeof(SmallBlockChainStream));
 
  newStream->parentStorage      = parentStorage;
  newStream->headOfStreamPlaceHolder = headOfStreamPlaceHolder;
  newStream->ownerDirEntry      = dirEntry;
 
  return newStream;
}

Referenced by Storage32Impl_BigBlocksToSmallBlocks(), StorageImpl_StreamReadAt(), StorageImpl_StreamSetSize(), and StorageImpl_StreamWriteAt().

SmallBlockChainStream_Destroy()

void SmallBlockChainStream_Destroy ( SmallBlockChainStream *  This )

static

Definition at line 7801 of file storage32.c.

{
  HeapFree(GetProcessHeap(), 0, This);
}

Referenced by Storage32Impl_BigBlocksToSmallBlocks(), Storage32Impl_SmallBlocksToBigBlocks(), StorageImpl_StreamReadAt(), StorageImpl_StreamSetSize(), and StorageImpl_StreamWriteAt().

SmallBlockChainStream_Enlarge()

static BOOL SmallBlockChainStream_Enlarge ( SmallBlockChainStream *  This, ULARGE_INTEGER  newSize  )

static

Definition at line 8315 of file storage32.c.

{
  ULONG blockIndex, currentBlock;
  ULONG newNumBlocks;
  ULONG oldNumBlocks = 0;
 
  blockIndex = SmallBlockChainStream_GetHeadOfChain(This);
 
  /*
   * Empty chain. Create the head.
   */
  if (blockIndex == BLOCK_END_OF_CHAIN)
  {
    blockIndex = SmallBlockChainStream_GetNextFreeBlock(This);
    SmallBlockChainStream_SetNextBlockInChain(
        This,
        blockIndex,
        BLOCK_END_OF_CHAIN);
 
    if (This->headOfStreamPlaceHolder != NULL)
    {
      *(This->headOfStreamPlaceHolder) = blockIndex;
    }
    else
    {
      DirEntry chainEntry;
 
      StorageImpl_ReadDirEntry(This->parentStorage, This->ownerDirEntry,
                                   &chainEntry);
 
      chainEntry.startingBlock = blockIndex;
 
      StorageImpl_WriteDirEntry(This->parentStorage, This->ownerDirEntry,
                                  &chainEntry);
    }
  }
 
  currentBlock = blockIndex;
 
  /*
   * Figure out how many blocks are needed to contain this stream
   */
  newNumBlocks = newSize.u.LowPart / This->parentStorage->smallBlockSize;
 
  if ((newSize.u.LowPart % This->parentStorage->smallBlockSize) != 0)
    newNumBlocks++;
 
  /*
   * Go to the current end of chain
   */
  while (blockIndex != BLOCK_END_OF_CHAIN)
  {
    oldNumBlocks++;
    currentBlock = blockIndex;
    if(FAILED(SmallBlockChainStream_GetNextBlockInChain(This, currentBlock, &blockIndex)))
      return FALSE;
  }
 
  /*
   * Add new blocks to the chain
   */
  while (oldNumBlocks < newNumBlocks)
  {
    blockIndex = SmallBlockChainStream_GetNextFreeBlock(This);
    SmallBlockChainStream_SetNextBlockInChain(This, currentBlock, blockIndex);
 
    SmallBlockChainStream_SetNextBlockInChain(
      This,
      blockIndex,
      BLOCK_END_OF_CHAIN);
 
    currentBlock = blockIndex;
    oldNumBlocks++;
  }
 
  return TRUE;
}

Referenced by SmallBlockChainStream_SetSize().

SmallBlockChainStream_FreeBlock()

static void SmallBlockChainStream_FreeBlock ( SmallBlockChainStream *  This, ULONG  blockIndex  )

static

Definition at line 7917 of file storage32.c.

{
  SmallBlockChainStream_SetNextBlockInChain(This, blockIndex, BLOCK_UNUSED);
}

Referenced by SmallBlockChainStream_Shrink().

SmallBlockChainStream_GetCount()

static ULONG SmallBlockChainStream_GetCount ( SmallBlockChainStream *  This )

static

Definition at line 8433 of file storage32.c.

{
    ULONG blockIndex;
    ULONG count = 0;
 
    blockIndex = SmallBlockChainStream_GetHeadOfChain(This);
 
    while(blockIndex != BLOCK_END_OF_CHAIN)
    {
        count++;
 
        if(FAILED(SmallBlockChainStream_GetNextBlockInChain(This,
                        blockIndex, &blockIndex)))
            return 0;
    }
 
    return count;
}

Referenced by SmallBlockChainStream_GetSize().

SmallBlockChainStream_GetHeadOfChain()

static ULONG SmallBlockChainStream_GetHeadOfChain ( SmallBlockChainStream *  This )

static

Definition at line 7812 of file storage32.c.

{
  DirEntry  chainEntry;
  HRESULT   hr;
 
  if (This->headOfStreamPlaceHolder != NULL)
    return *(This->headOfStreamPlaceHolder);
 
  if (This->ownerDirEntry)
  {
    hr = StorageImpl_ReadDirEntry(
                      This->parentStorage,
                      This->ownerDirEntry,
                      &chainEntry);
 
    if (SUCCEEDED(hr) && chainEntry.startingBlock < BLOCK_FIRST_SPECIAL)
      return chainEntry.startingBlock;
  }
 
  return BLOCK_END_OF_CHAIN;
}

Referenced by SmallBlockChainStream_Enlarge(), SmallBlockChainStream_GetCount(), SmallBlockChainStream_ReadAt(), SmallBlockChainStream_Shrink(), and SmallBlockChainStream_WriteAt().

SmallBlockChainStream_GetNextBlockInChain()

static HRESULT SmallBlockChainStream_GetNextBlockInChain ( SmallBlockChainStream *  This, ULONG  blockIndex, ULONG *  nextBlockInChain  )

static

Definition at line 7844 of file storage32.c.

{
  ULARGE_INTEGER offsetOfBlockInDepot;
  DWORD  buffer;
  ULONG  bytesRead;
  HRESULT res;
 
  *nextBlockInChain = BLOCK_END_OF_CHAIN;
 
  offsetOfBlockInDepot.QuadPart  = (ULONGLONG)blockIndex * sizeof(ULONG);
 
  /*
   * Read those bytes in the buffer from the small block file.
   */
  res = BlockChainStream_ReadAt(
              This->parentStorage->smallBlockDepotChain,
              offsetOfBlockInDepot,
              sizeof(DWORD),
              &buffer,
              &bytesRead);
 
  if (SUCCEEDED(res) && bytesRead != sizeof(DWORD))
    res = STG_E_READFAULT;
 
  if (SUCCEEDED(res))
  {
    StorageUtl_ReadDWord((BYTE *)&buffer, 0, nextBlockInChain);
    return S_OK;
  }
 
  return res;
}

Referenced by SmallBlockChainStream_Enlarge(), SmallBlockChainStream_GetCount(), SmallBlockChainStream_ReadAt(), SmallBlockChainStream_Shrink(), and SmallBlockChainStream_WriteAt().

SmallBlockChainStream_GetNextFreeBlock()

static ULONG SmallBlockChainStream_GetNextFreeBlock ( SmallBlockChainStream *  This )

static

Definition at line 7931 of file storage32.c.

{
  ULARGE_INTEGER offsetOfBlockInDepot;
  DWORD buffer;
  ULONG bytesRead;
  ULONG blockIndex = This->parentStorage->firstFreeSmallBlock;
  ULONG nextBlockIndex = BLOCK_END_OF_CHAIN;
  HRESULT res = S_OK;
  ULONG smallBlocksPerBigBlock;
  DirEntry rootEntry;
  ULONG blocksRequired;
  ULARGE_INTEGER old_size, size_required;
 
  offsetOfBlockInDepot.u.HighPart = 0;
 
  /*
   * Scan the small block depot for a free block
   */
  while (nextBlockIndex != BLOCK_UNUSED)
  {
    offsetOfBlockInDepot.QuadPart = (ULONGLONG)blockIndex * sizeof(ULONG);
 
    res = BlockChainStream_ReadAt(
                This->parentStorage->smallBlockDepotChain,
                offsetOfBlockInDepot,
                sizeof(DWORD),
                &buffer,
                &bytesRead);
 
    /*
     * If we run out of space for the small block depot, enlarge it
     */
    if (SUCCEEDED(res) && bytesRead == sizeof(DWORD))
    {
      StorageUtl_ReadDWord((BYTE *)&buffer, 0, &nextBlockIndex);
 
      if (nextBlockIndex != BLOCK_UNUSED)
        blockIndex++;
    }
    else
    {
      ULONG count =
        BlockChainStream_GetCount(This->parentStorage->smallBlockDepotChain);
 
      BYTE smallBlockDepot[MAX_BIG_BLOCK_SIZE];
      ULARGE_INTEGER newSize, offset;
      ULONG bytesWritten;
 
      newSize.QuadPart = (ULONGLONG)(count + 1) * This->parentStorage->bigBlockSize;
      BlockChainStream_Enlarge(This->parentStorage->smallBlockDepotChain, newSize);
 
      /*
       * Initialize all the small blocks to free
       */
      memset(smallBlockDepot, BLOCK_UNUSED, This->parentStorage->bigBlockSize);
      offset.QuadPart = (ULONGLONG)count * This->parentStorage->bigBlockSize;
      BlockChainStream_WriteAt(This->parentStorage->smallBlockDepotChain,
        offset, This->parentStorage->bigBlockSize, smallBlockDepot, &bytesWritten);
 
      StorageImpl_SaveFileHeader(This->parentStorage);
    }
  }
 
  This->parentStorage->firstFreeSmallBlock = blockIndex+1;
 
  smallBlocksPerBigBlock =
    This->parentStorage->bigBlockSize / This->parentStorage->smallBlockSize;
 
  /*
   * Verify if we have to allocate big blocks to contain small blocks
   */
  blocksRequired = (blockIndex / smallBlocksPerBigBlock) + 1;
 
  size_required.QuadPart = (ULONGLONG)blocksRequired * This->parentStorage->bigBlockSize;
 
  old_size = BlockChainStream_GetSize(This->parentStorage->smallBlockRootChain);
 
  if (size_required.QuadPart > old_size.QuadPart)
  {
    BlockChainStream_SetSize(
      This->parentStorage->smallBlockRootChain,
      size_required);
 
    StorageImpl_ReadDirEntry(
      This->parentStorage,
      This->parentStorage->base.storageDirEntry,
      &rootEntry);
 
    rootEntry.size = size_required;
 
    StorageImpl_WriteDirEntry(
      This->parentStorage,
      This->parentStorage->base.storageDirEntry,
      &rootEntry);
  }
 
  return blockIndex;
}

Referenced by SmallBlockChainStream_Enlarge().

SmallBlockChainStream_GetSize()

static ULARGE_INTEGER SmallBlockChainStream_GetSize ( SmallBlockChainStream *  This )

static

Definition at line 8457 of file storage32.c.

{
  DirEntry chainEntry;
 
  if(This->headOfStreamPlaceHolder != NULL)
  {
    ULARGE_INTEGER result;
    result.u.HighPart = 0;
 
    result.u.LowPart = SmallBlockChainStream_GetCount(This) *
        This->parentStorage->smallBlockSize;
 
    return result;
  }
 
  StorageImpl_ReadDirEntry(
    This->parentStorage,
    This->ownerDirEntry,
    &chainEntry);
 
  return chainEntry.size;
}

Referenced by SmallBlockChainStream_ReadAt(), SmallBlockChainStream_SetSize(), and Storage32Impl_SmallBlocksToBigBlocks().

SmallBlockChainStream_ReadAt()

HRESULT SmallBlockChainStream_ReadAt ( SmallBlockChainStream *  This, ULARGE_INTEGER  offset, ULONG  size, void *  buffer, ULONG *  bytesRead  )

static

Definition at line 8038 of file storage32.c.

{
  HRESULT rc = S_OK;
  ULARGE_INTEGER offsetInBigBlockFile;
  ULONG blockNoInSequence =
    offset.u.LowPart / This->parentStorage->smallBlockSize;
 
  ULONG offsetInBlock = offset.u.LowPart % This->parentStorage->smallBlockSize;
  ULONG bytesToReadInBuffer;
  ULONG blockIndex;
  ULONG bytesReadFromBigBlockFile;
  BYTE* bufferWalker;
  ULARGE_INTEGER stream_size;
 
  /*
   * This should never happen on a small block file.
   */
  assert(offset.u.HighPart==0);
 
  *bytesRead   = 0;
 
  stream_size = SmallBlockChainStream_GetSize(This);
  if (stream_size.QuadPart > offset.QuadPart)
    size = min(stream_size.QuadPart - offset.QuadPart, size);
  else
    return S_OK;
 
  /*
   * Find the first block in the stream that contains part of the buffer.
   */
  blockIndex = SmallBlockChainStream_GetHeadOfChain(This);
 
  while ( (blockNoInSequence > 0) &&  (blockIndex != BLOCK_END_OF_CHAIN))
  {
    rc = SmallBlockChainStream_GetNextBlockInChain(This, blockIndex, &blockIndex);
    if(FAILED(rc))
      return rc;
    blockNoInSequence--;
  }
 
  /*
   * Start reading the buffer.
   */
  bufferWalker = buffer;
 
  while ( (size > 0) && (blockIndex != BLOCK_END_OF_CHAIN) )
  {
    /*
     * Calculate how many bytes we can copy from this small block.
     */
    bytesToReadInBuffer =
      min(This->parentStorage->smallBlockSize - offsetInBlock, size);
 
    /*
     * Calculate the offset of the small block in the small block file.
     */