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.
     */
    offsetInBigBlockFile.QuadPart   =
      (ULONGLONG)blockIndex * This->parentStorage->smallBlockSize;
 
    offsetInBigBlockFile.QuadPart  += offsetInBlock;
 
    /*
     * Read those bytes in the buffer from the small block file.
     * The small block has already been identified so it shouldn't fail
     * unless the file is corrupt.
     */
    rc = BlockChainStream_ReadAt(This->parentStorage->smallBlockRootChain,
      offsetInBigBlockFile,
      bytesToReadInBuffer,
      bufferWalker,
      &bytesReadFromBigBlockFile);
 
    if (FAILED(rc))
      return rc;
 
    if (!bytesReadFromBigBlockFile)
      return STG_E_DOCFILECORRUPT;
 
    /*
     * Step to the next big block.
     */
    rc = SmallBlockChainStream_GetNextBlockInChain(This, blockIndex, &blockIndex);
    if(FAILED(rc))
      return STG_E_DOCFILECORRUPT;
 
    bufferWalker += bytesReadFromBigBlockFile;
    size         -= bytesReadFromBigBlockFile;
    *bytesRead   += bytesReadFromBigBlockFile;
    offsetInBlock = (offsetInBlock + bytesReadFromBigBlockFile) % This->parentStorage->smallBlockSize;
  }
 
  return S_OK;
}

Referenced by Storage32Impl_SmallBlocksToBigBlocks(), and StorageImpl_StreamReadAt().

SmallBlockChainStream_SetNextBlockInChain()

static void SmallBlockChainStream_SetNextBlockInChain ( SmallBlockChainStream *  This, ULONG  blockIndex, ULONG  nextBlock  )

static

Definition at line 7888 of file storage32.c.

{
  ULARGE_INTEGER offsetOfBlockInDepot;
  DWORD  buffer;
  ULONG  bytesWritten;
 
  offsetOfBlockInDepot.QuadPart  = (ULONGLONG)blockIndex * sizeof(ULONG);
 
  StorageUtl_WriteDWord((BYTE *)&buffer, 0, nextBlock);
 
  /*
   * Read those bytes in the buffer from the small block file.
   */
  BlockChainStream_WriteAt(
    This->parentStorage->smallBlockDepotChain,
    offsetOfBlockInDepot,
    sizeof(DWORD),
    &buffer,
    &bytesWritten);
}

Referenced by SmallBlockChainStream_Enlarge(), SmallBlockChainStream_FreeBlock(), and SmallBlockChainStream_Shrink().

SmallBlockChainStream_SetSize()

BOOL SmallBlockChainStream_SetSize ( SmallBlockChainStream *  This, ULARGE_INTEGER  newSize  )

static

Definition at line 8405 of file storage32.c.

{
  ULARGE_INTEGER size = SmallBlockChainStream_GetSize(This);
 
  if (newSize.u.LowPart == size.u.LowPart)
    return TRUE;
 
  if (newSize.u.LowPart < size.u.LowPart)
  {
    SmallBlockChainStream_Shrink(This, newSize);
  }
  else
  {
    SmallBlockChainStream_Enlarge(This, newSize);
  }
 
  return TRUE;
}

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

SmallBlockChainStream_Shrink()

static BOOL SmallBlockChainStream_Shrink ( SmallBlockChainStream *  This, ULARGE_INTEGER  newSize  )

static

Definition at line 8231 of file storage32.c.

{
  ULONG blockIndex, extraBlock;
  ULONG numBlocks;
  ULONG count = 0;
 
  numBlocks = newSize.u.LowPart / This->parentStorage->smallBlockSize;
 
  if ((newSize.u.LowPart % This->parentStorage->smallBlockSize) != 0)
    numBlocks++;
 
  blockIndex = SmallBlockChainStream_GetHeadOfChain(This);
 
  /*
   * Go to the new end of chain
   */
  while (count < numBlocks)
  {
    if(FAILED(SmallBlockChainStream_GetNextBlockInChain(This, blockIndex,
                            &blockIndex)))
      return FALSE;
    count++;
  }
 
  /*
   * If the count is 0, we have a special case, the head of the chain was
   * just freed.
   */
  if (count == 0)
  {
    DirEntry chainEntry;
 
    StorageImpl_ReadDirEntry(This->parentStorage,
                 This->ownerDirEntry,
                 &chainEntry);
 
    chainEntry.startingBlock = BLOCK_END_OF_CHAIN;
 
    StorageImpl_WriteDirEntry(This->parentStorage,
                  This->ownerDirEntry,
                  &chainEntry);
 
    /*
     * We start freeing the chain at the head block.
     */
    extraBlock = blockIndex;
  }
  else
  {
    /* Get the next block before marking the new end */
    if(FAILED(SmallBlockChainStream_GetNextBlockInChain(This, blockIndex,
                            &extraBlock)))
      return FALSE;
 
    /* Mark the new end of chain */
    SmallBlockChainStream_SetNextBlockInChain(
      This,
      blockIndex,
      BLOCK_END_OF_CHAIN);
  }
 
  /*
   * Mark the extra blocks as free
   */
  while (extraBlock != BLOCK_END_OF_CHAIN)
  {
    if(FAILED(SmallBlockChainStream_GetNextBlockInChain(This, extraBlock,
                            &blockIndex)))
      return FALSE;
    SmallBlockChainStream_FreeBlock(This, extraBlock);
    This->parentStorage->firstFreeSmallBlock = min(This->parentStorage->firstFreeSmallBlock, extraBlock);
    extraBlock = blockIndex;
  }
 
  return TRUE;
}

Referenced by SmallBlockChainStream_SetSize().

SmallBlockChainStream_WriteAt()

HRESULT SmallBlockChainStream_WriteAt ( SmallBlockChainStream *  This, ULARGE_INTEGER  offset, ULONG  size, const void *  buffer, ULONG *  bytesWritten  )

static

Definition at line 8143 of file storage32.c.

{
  ULARGE_INTEGER offsetInBigBlockFile;
  ULONG blockNoInSequence =
    offset.u.LowPart / This->parentStorage->smallBlockSize;
 
  ULONG offsetInBlock = offset.u.LowPart % This->parentStorage->smallBlockSize;
  ULONG bytesToWriteInBuffer;
  ULONG blockIndex;
  ULONG bytesWrittenToBigBlockFile;
  const BYTE* bufferWalker;
  HRESULT res;
 
  /*
   * This should never happen on a small block file.
   */
  assert(offset.u.HighPart==0);
 
  /*
   * 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))
  {
    if(FAILED(SmallBlockChainStream_GetNextBlockInChain(This, blockIndex, &blockIndex)))
      return STG_E_DOCFILECORRUPT;
    blockNoInSequence--;
  }
 
  /*
   * Start writing the buffer.
   */
  *bytesWritten   = 0;
  bufferWalker = buffer;
  while ( (size > 0) && (blockIndex != BLOCK_END_OF_CHAIN) )
  {
    /*
     * Calculate how many bytes we can copy to this small block.
     */
    bytesToWriteInBuffer =
      min(This->parentStorage->smallBlockSize - offsetInBlock, size);
 
    /*
     * Calculate the offset of the small block in the small block file.
     */
    offsetInBigBlockFile.QuadPart   =
      (ULONGLONG)blockIndex * This->parentStorage->smallBlockSize;
 
    offsetInBigBlockFile.QuadPart  += offsetInBlock;
 
    /*
     * Write those bytes in the buffer to the small block file.
     */
    res = BlockChainStream_WriteAt(
      This->parentStorage->smallBlockRootChain,
      offsetInBigBlockFile,
      bytesToWriteInBuffer,
      bufferWalker,
      &bytesWrittenToBigBlockFile);
    if (FAILED(res))
      return res;
 
    /*
     * Step to the next big block.
     */
    res = SmallBlockChainStream_GetNextBlockInChain(This, blockIndex, &blockIndex);
    if (FAILED(res))
      return res;
    bufferWalker  += bytesWrittenToBigBlockFile;
    size          -= bytesWrittenToBigBlockFile;
    *bytesWritten += bytesWrittenToBigBlockFile;
    offsetInBlock  = (offsetInBlock + bytesWrittenToBigBlockFile) % This->parentStorage->smallBlockSize;
  }
 
  return (size == 0) ? S_OK : STG_E_WRITEFAULT;
}

Referenced by Storage32Impl_BigBlocksToSmallBlocks(), and StorageImpl_StreamWriteAt().

StgCreateDocfile()

HRESULT WINAPI StgCreateDocfile	(	LPCOLESTR	pwcsName,
		DWORD	grfMode,
		DWORD	reserved,
		IStorage **	ppstgOpen
	)

Definition at line 8636 of file storage32.c.

{
  STGOPTIONS stgoptions = {1, 0, 512};
 
  TRACE("(%s, %x, %d, %p)\n",
    debugstr_w(pwcsName), grfMode,
    reserved, ppstgOpen);
 
  if (ppstgOpen == 0)
    return STG_E_INVALIDPOINTER;
  if (reserved != 0)
    return STG_E_INVALIDPARAMETER;
 
  return create_storagefile(pwcsName, grfMode, 0, &stgoptions, &IID_IStorage, (void**)ppstgOpen);
}

Referenced by create_patch(), create_storage(), create_storage_from_def(), generate_transform_manual(), MSI_OpenDatabaseW(), OLECONVERT_WriteOLE20ToBuffer(), setup_richedit_olecallback(), START_TEST(), test_access(), test_convert(), test_copyto(), test_copyto_iidexclusions_storage(), test_copyto_iidexclusions_stream(), test_copyto_locking(), test_copyto_recursive(), test_copyto_snbexclusions(), test_create_database_binary(), test_create_storage_modes(), test_data_cache(), test_data_cache_contents(), test_data_cache_initnew(), test_direct_swmr(), test_DPA_LoadStream(), test_DPA_SaveStream(), test_fmtusertypestg(), test_getdatahere(), test_locking(), test_nonroot_transacted(), test_OleLoad(), test_open_storage(), test_overwrite(), test_parent_free(), test_readonly(), test_references(), test_rename(), test_revert(), test_simple(), test_storage_refcount(), test_storage_stream(), test_storage_suminfo(), test_streamenum(), test_substorage_enum(), test_substorage_share(), test_toplevel_stat(), test_transact(), test_transacted_shared(), test_writeclassstg(), testCodepage(), testPropsHelper(), TransactedSnapshotImpl_Construct(), and write_substorage_to_file().

StgCreateDocfileOnILockBytes()

HRESULT WINAPI StgCreateDocfileOnILockBytes	(	ILockBytes *	plkbyt,
		DWORD	grfMode,
		DWORD	reserved,
		IStorage **	ppstgOpen
	)

Definition at line 8946 of file storage32.c.

{
  StorageBaseImpl* newStorage = 0;
  HRESULT        hr         = S_OK;
 
  if ((ppstgOpen == 0) || (plkbyt == 0))
    return STG_E_INVALIDPOINTER;
 
  /*
   * Allocate and initialize the new IStorage object.
   */
  hr = Storage_Construct(
         0,
        0,
         plkbyt,
         grfMode,
         FALSE,
         TRUE,
         512,
         &newStorage);
 
  if (FAILED(hr))
  {
    return hr;
  }
 
  *ppstgOpen = &newStorage->IStorage_iface;
 
  return hr;
}

Referenced by create_storage(), DataObjectImpl_CreateComplex(), get_data_from_storage(), render_embed_source_hack(), test_custom_lockbytes(), test_data_cache_save(), test_data_cache_save_data(), test_hglobal_storage_creation(), test_hglobal_storage_stat(), and test_OleCreateStaticFromData().

StgCreatePropSetStg()

HRESULT WINAPI StgCreatePropSetStg	(	IStorage *	pstg,
		DWORD	reserved,
		IPropertySetStorage **	propset
	)

Definition at line 8698 of file storage32.c.

{
    TRACE("(%p, 0x%x, %p)\n", pstg, reserved, propset);
    if (reserved)
        return STG_E_INVALIDPARAMETER;
 
    return IStorage_QueryInterface(pstg, &IID_IPropertySetStorage, (void**)propset);
}

StgCreateStorageEx()

HRESULT WINAPI StgCreateStorageEx	(	const WCHAR *	pwcsName,
		DWORD	grfMode,
		DWORD	stgfmt,
		DWORD	grfAttrs,
		STGOPTIONS *	pStgOptions,
		void *	reserved,
		REFIID	riid,
		void **	ppObjectOpen
	)

Definition at line 8659 of file storage32.c.

{
    TRACE("(%s, %x, %x, %x, %p, %p, %p, %p)\n", debugstr_w(pwcsName),
          grfMode, stgfmt, grfAttrs, pStgOptions, reserved, riid, ppObjectOpen);
 
    if (stgfmt != STGFMT_FILE && grfAttrs != 0)
    {
        ERR("grfAttrs must be 0 if stgfmt != STGFMT_FILE\n");
        return STG_E_INVALIDPARAMETER;
    }
 
    if (stgfmt == STGFMT_FILE && grfAttrs != 0 && grfAttrs != FILE_FLAG_NO_BUFFERING)
    {
        ERR("grfAttrs must be 0 or FILE_FLAG_NO_BUFFERING if stgfmt == STGFMT_FILE\n");
        return STG_E_INVALIDPARAMETER;
    }
 
    if (stgfmt == STGFMT_FILE)
    {
        ERR("Cannot use STGFMT_FILE - this is NTFS only\n");
        return STG_E_INVALIDPARAMETER;
    }
 
    if (stgfmt == STGFMT_STORAGE || stgfmt == STGFMT_DOCFILE)
    {
        STGOPTIONS defaultOptions = {1, 0, 512};
 
        if (!pStgOptions) pStgOptions = &defaultOptions;
        return create_storagefile(pwcsName, grfMode, grfAttrs, pStgOptions, riid, ppObjectOpen);
    }
 
 
    ERR("Invalid stgfmt argument\n");
    return STG_E_INVALIDPARAMETER;
}

Referenced by create_shortcut(), and TransactedSharedImpl_Construct().

StgIsStorageFile()

HRESULT WINAPI StgIsStorageFile

(

LPCOLESTR

fn

)

Definition at line 9475 of file storage32.c.

{
    HANDLE      hf;
    BYTE        magic[8];
    DWORD       bytes_read;
 
    TRACE("%s\n", debugstr_w(fn));
    hf = CreateFileW(fn, GENERIC_READ,
                     FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
                     NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
 
    if (hf == INVALID_HANDLE_VALUE)
        return STG_E_FILENOTFOUND;
 
    if (!ReadFile(hf, magic, 8, &bytes_read, NULL))
    {
        WARN(" unable to read file\n");
        CloseHandle(hf);
        return S_FALSE;
    }
 
    CloseHandle(hf);
 
    if (bytes_read != 8) {
        TRACE(" too short\n");
        return S_FALSE;
    }
 
    if (!memcmp(magic,STORAGE_magic,8)) {
        TRACE(" -> YES\n");
        return S_OK;
    }
 
    TRACE(" -> Invalid header.\n");
    return S_FALSE;
}

Referenced by GetClassFile().

StgIsStorageILockBytes()

HRESULT WINAPI StgIsStorageILockBytes

(

ILockBytes *

plkbyt

)

Definition at line 9056 of file storage32.c.

{
  BYTE sig[sizeof(STORAGE_magic)];
  ULARGE_INTEGER offset;
  ULONG read = 0;
 
  offset.u.HighPart = 0;
  offset.u.LowPart  = 0;
 
  ILockBytes_ReadAt(plkbyt, offset, sig, sizeof(sig), &read);
 
  if (read == sizeof(sig) && memcmp(sig, STORAGE_magic, sizeof(sig)) == 0)
    return S_OK;
 
  return S_FALSE;
}

Referenced by get_stgmed_for_storage(), and test_hglobal_storage_stat().

StgOpenStorage()

HRESULT WINAPI StgOpenStorage	(	const OLECHAR *	pwcsName,
		IStorage *	pstgPriority,
		DWORD	grfMode,
		SNB	snbExclude,
		DWORD	reserved,
		IStorage **	ppstgOpen
	)

Definition at line 8755 of file storage32.c.

{
  StorageBaseImpl* newStorage = 0;
  HRESULT        hr = S_OK;
  HANDLE         hFile = 0;
  DWORD          shareMode;
  DWORD          accessMode;
  LPWSTR         temp_name = NULL;
 
  TRACE("(%s, %p, %x, %p, %d, %p)\n",
    debugstr_w(pwcsName), pstgPriority, grfMode,
    snbExclude, reserved, ppstgOpen);
 
  if (pstgPriority)
  {
    /* FIXME: Copy ILockBytes instead? But currently for STGM_PRIORITY it'll be read-only. */
    hr = StorageBaseImpl_GetFilename((StorageBaseImpl*)pstgPriority, &temp_name);
    if (FAILED(hr)) goto end;
    pwcsName = temp_name;
    TRACE("using filename %s\n", debugstr_w(temp_name));
  }
 
  if (pwcsName == 0)
  {
    hr = STG_E_INVALIDNAME;
    goto end;
  }
 
  if (ppstgOpen == 0)
  {
    hr = STG_E_INVALIDPOINTER;
    goto end;
  }
 
  if (reserved)
  {
    hr = STG_E_INVALIDPARAMETER;
    goto end;
  }
 
  if (grfMode & STGM_PRIORITY)
  {
    if (grfMode & (STGM_TRANSACTED|STGM_SIMPLE|STGM_NOSCRATCH|STGM_NOSNAPSHOT))
      return STG_E_INVALIDFLAG;
    if (grfMode & STGM_DELETEONRELEASE)
      return STG_E_INVALIDFUNCTION;
    if(STGM_ACCESS_MODE(grfMode) != STGM_READ)
      return STG_E_INVALIDFLAG;
    grfMode &= ~0xf0; /* remove the existing sharing mode */
    grfMode |= STGM_SHARE_DENY_NONE;
  }
 
  /*
   * Validate the sharing mode
   */
  if (grfMode & STGM_DIRECT_SWMR)
  {
    if ((STGM_SHARE_MODE(grfMode) != STGM_SHARE_DENY_WRITE) &&
        (STGM_SHARE_MODE(grfMode) != STGM_SHARE_DENY_NONE))
    {
      hr = STG_E_INVALIDFLAG;
      goto end;
    }
  }
  else if (!(grfMode & (STGM_TRANSACTED|STGM_PRIORITY)))
    switch(STGM_SHARE_MODE(grfMode))
    {
      case STGM_SHARE_EXCLUSIVE:
      case STGM_SHARE_DENY_WRITE:
        break;
      default:
        hr = STG_E_INVALIDFLAG;
        goto end;
    }
 
  if ( FAILED( validateSTGM(grfMode) ) ||
       (grfMode&STGM_CREATE))
  {
    hr = STG_E_INVALIDFLAG;
    goto end;
  }
 
  /* shared reading requires transacted or single writer mode */
  if( STGM_SHARE_MODE(grfMode) == STGM_SHARE_DENY_WRITE &&
      STGM_ACCESS_MODE(grfMode) == STGM_READWRITE &&
     !(grfMode & STGM_TRANSACTED) && !(grfMode & STGM_DIRECT_SWMR))
  {
    hr = STG_E_INVALIDFLAG;
    goto end;
  }
 
  /*
   * Interpret the STGM value grfMode
   */
  shareMode    = GetShareModeFromSTGM(grfMode);
  accessMode   = GetAccessModeFromSTGM(grfMode);
 
  *ppstgOpen = 0;
 
  hFile = CreateFileW( pwcsName,
                       accessMode,
                       shareMode,
                       NULL,
                       OPEN_EXISTING,
                       FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
                       0);
 
  if (hFile==INVALID_HANDLE_VALUE)
  {
    DWORD last_error = GetLastError();
 
    hr = E_FAIL;
 
    switch (last_error)
    {
      case ERROR_FILE_NOT_FOUND:
        hr = STG_E_FILENOTFOUND;
        break;
 
      case ERROR_PATH_NOT_FOUND:
        hr = STG_E_PATHNOTFOUND;
        break;
 
      case ERROR_ACCESS_DENIED:
      case ERROR_WRITE_PROTECT:
        hr = STG_E_ACCESSDENIED;
        break;
 
      case ERROR_SHARING_VIOLATION:
        hr = STG_E_SHAREVIOLATION;
        break;
 
      default:
        hr = E_FAIL;
    }
 
    goto end;
  }
 
  /*
   * Refuse to open the file if it's too small to be a structured storage file
   * FIXME: verify the file when reading instead of here
   */
  if (GetFileSize(hFile, NULL) < HEADER_SIZE)
  {
    CloseHandle(hFile);
    hr = STG_E_FILEALREADYEXISTS;
    goto end;
  }
 
  /*
   * Allocate and initialize the new IStorage object.
   */
  hr = Storage_Construct(
         hFile,
         pwcsName,
         NULL,
         grfMode,
         TRUE,
         FALSE,
         512,
         &newStorage);
 
  if (FAILED(hr))
  {
    /*
     * According to the docs if the file is not a storage, return STG_E_FILEALREADYEXISTS
     */
    if(hr == STG_E_INVALIDHEADER)
    hr = STG_E_FILEALREADYEXISTS;
    goto end;
  }
 
  *ppstgOpen = &newStorage->IStorage_iface;
 
end:
  CoTaskMemFree(temp_name);
  if (pstgPriority) IStorage_Release(pstgPriority);
  TRACE("<-- %08x, IStorage %p\n", hr, ppstgOpen ? *ppstgOpen : NULL);
  return hr;
}

Referenced by add_cabinet_storage(), FileMonikerImpl_BindToStorage(), GetClassFile(), MSI_DatabaseApplyTransformW(), MSI_OpenDatabaseW(), MsiSIPGetSignedDataMsg(), MsiSIPIsMyTypeOfFile(), OLECONVERT_GetOLE20FromOLE10(), set_admin_property_stream(), StgOpenStorageEx(), StgSetTimes(), test_access(), test_defaultdatabase(), test_direct_swmr(), test_locking(), test_open_storage(), test_overwrite(), test_readonly(), test_references(), test_simple(), test_storage_refcount(), test_storage_stream(), test_storages_table(), test_streamenum(), test_stringtable(), test_toplevel_stat(), test_transact(), test_transacted_shared(), and testPropsHelper().

StgOpenStorageEx()

HRESULT WINAPI StgOpenStorageEx	(	const WCHAR *	pwcsName,
		DWORD	grfMode,
		DWORD	stgfmt,
		DWORD	grfAttrs,
		STGOPTIONS *	pStgOptions,
		void *	reserved,
		REFIID	riid,
		void **	ppObjectOpen
	)

Definition at line 8711 of file storage32.c.

{
    TRACE("(%s, %x, %x, %x, %p, %p, %p, %p)\n", debugstr_w(pwcsName),
          grfMode, stgfmt, grfAttrs, pStgOptions, reserved, riid, ppObjectOpen);
 
    if (stgfmt != STGFMT_DOCFILE && grfAttrs != 0)
    {
        ERR("grfAttrs must be 0 if stgfmt != STGFMT_DOCFILE\n");
        return STG_E_INVALIDPARAMETER;
    }
 
    switch (stgfmt)
    {
    case STGFMT_FILE:
        ERR("Cannot use STGFMT_FILE - this is NTFS only\n");
        return STG_E_INVALIDPARAMETER;
 
    case STGFMT_STORAGE:
        break;
 
    case STGFMT_DOCFILE:
        if (grfAttrs && grfAttrs != FILE_FLAG_NO_BUFFERING)
        {
            ERR("grfAttrs must be 0 or FILE_FLAG_NO_BUFFERING if stgfmt == STGFMT_DOCFILE\n");
            return STG_E_INVALIDPARAMETER;
        }
        FIXME("Stub: calling StgOpenStorage, but ignoring pStgOptions and grfAttrs\n");
        break;
 
    case STGFMT_ANY:
        WARN("STGFMT_ANY assuming storage\n");
        break;
 
    default:
        return STG_E_INVALIDPARAMETER;
    }
 
    return StgOpenStorage(pwcsName, NULL, grfMode, NULL, 0, (IStorage **)ppObjectOpen);
}

StgOpenStorageOnILockBytes()

HRESULT WINAPI StgOpenStorageOnILockBytes	(	ILockBytes *	plkbyt,
		IStorage *	pstgPriority,
		DWORD	grfMode,
		SNB	snbExclude,
		DWORD	reserved,
		IStorage **	ppstgOpen
	)

Definition at line 8984 of file storage32.c.

{
  StorageBaseImpl* newStorage = 0;
  HRESULT        hr = S_OK;
 
  if ((plkbyt == 0) || (ppstgOpen == 0))
    return STG_E_INVALIDPOINTER;
 
  if ( FAILED( validateSTGM(grfMode) ))
    return STG_E_INVALIDFLAG;
 
  *ppstgOpen = 0;
 
  /*
   * Allocate and initialize the new IStorage object.
   */
  hr = Storage_Construct(
         0,
         0,
         plkbyt,
         grfMode,
         FALSE,
         FALSE,
         512,
         &newStorage);
 
  if (FAILED(hr))
  {
    return hr;
  }
 
  *ppstgOpen = &newStorage->IStorage_iface;
 
  return hr;
}

Referenced by get_stgmed_for_storage(), stream_to_storage(), and test_hglobal_storage_creation().

StgSetTimes()

HRESULT WINAPI StgSetTimes	(	OLECHAR const *	str,
		FILETIME const *	pctime,
		FILETIME const *	patime,
		FILETIME const *	pmtime
	)

Definition at line 9032 of file storage32.c.

{
  IStorage *stg = NULL;
  HRESULT r;
 
  TRACE("%s %p %p %p\n", debugstr_w(str), pctime, patime, pmtime);
 
  r = StgOpenStorage(str, NULL, STGM_READWRITE | STGM_SHARE_DENY_WRITE,
                     0, 0, &stg);
  if( SUCCEEDED(r) )
  {
    r = IStorage_SetElementTimes(stg, NULL, pctime, patime, pmtime);
    IStorage_Release(stg);
  }
 
  return r;
}

Storage32Impl_AddBlockDepot()

static void Storage32Impl_AddBlockDepot ( StorageImpl *  This, ULONG  blockIndex, ULONG  depotIndex  )

static

Definition at line 3835 of file storage32.c.

{
  BYTE blockBuffer[MAX_BIG_BLOCK_SIZE];
  ULONG rangeLockIndex = RANGELOCK_FIRST / This->bigBlockSize - 1;
  ULONG blocksPerDepot = This->bigBlockSize / sizeof(ULONG);
  ULONG rangeLockDepot = rangeLockIndex / blocksPerDepot;
 
  /*
   * Initialize blocks as free
   */
  memset(blockBuffer, BLOCK_UNUSED, This->bigBlockSize);
 
  /* Reserve the range lock sector */
  if (depotIndex == rangeLockDepot)
  {
    ((ULONG*)blockBuffer)[rangeLockIndex % blocksPerDepot] = BLOCK_END_OF_CHAIN;
  }
 
  StorageImpl_WriteBigBlock(This, blockIndex, blockBuffer);
}

Referenced by StorageImpl_GetNextFreeBigBlock().

Storage32Impl_AddExtBlockDepot()

static ULONG Storage32Impl_AddExtBlockDepot ( StorageImpl *  This )

static

Definition at line 3940 of file storage32.c.

{
  ULONG numExtBlocks           = This->extBigBlockDepotCount;
  ULONG nextExtBlock           = This->extBigBlockDepotStart;
  BYTE  depotBuffer[MAX_BIG_BLOCK_SIZE];
  ULONG index                  = BLOCK_UNUSED;
  ULONG nextBlockOffset        = This->bigBlockSize - sizeof(ULONG);
  ULONG blocksPerDepotBlock    = This->bigBlockSize / sizeof(ULONG);
  ULONG depotBlocksPerExtBlock = blocksPerDepotBlock - 1;
 
  index = (COUNT_BBDEPOTINHEADER + (numExtBlocks * depotBlocksPerExtBlock)) *
          blocksPerDepotBlock;
 
  if ((numExtBlocks == 0) && (nextExtBlock == BLOCK_END_OF_CHAIN))
  {
    /*
     * The first extended block.
     */
    This->extBigBlockDepotStart = index;
  }
  else
  {
    /*
     * Find the last existing extended block.
     */
    nextExtBlock = This->extBigBlockDepotLocations[This->extBigBlockDepotCount-1];
 
    /*
     * Add the new extended block to the chain.
     */
    StorageImpl_WriteDWordToBigBlock(This, nextExtBlock, nextBlockOffset,
                                     index);
  }
 
  /*
   * Initialize this block.
   */
  memset(depotBuffer, BLOCK_UNUSED, This->bigBlockSize);
  StorageImpl_WriteBigBlock(This, index, depotBuffer);
 
  /* Add the block to our cache. */
  if (This->extBigBlockDepotLocationsSize == numExtBlocks)
  {
    ULONG new_cache_size = (This->extBigBlockDepotLocationsSize+1)*2;
    ULONG *new_cache = HeapAlloc(GetProcessHeap(), 0, sizeof(ULONG) * new_cache_size);
 
    memcpy(new_cache, This->extBigBlockDepotLocations, sizeof(ULONG) * This->extBigBlockDepotLocationsSize);
    HeapFree(GetProcessHeap(), 0, This->extBigBlockDepotLocations);
 
    This->extBigBlockDepotLocations = new_cache;
    This->extBigBlockDepotLocationsSize = new_cache_size;
  }
  This->extBigBlockDepotLocations[numExtBlocks] = index;
 
  return index;
}

Referenced by StorageImpl_GetNextFreeBigBlock().

Storage32Impl_BigBlocksToSmallBlocks()

static SmallBlockChainStream * Storage32Impl_BigBlocksToSmallBlocks ( StorageImpl *  This, BlockChainStream **  ppbbChain, ULARGE_INTEGER  newSize  )

static

Definition at line 3746 of file storage32.c.

{
    ULARGE_INTEGER size, offset, cbTotalRead;
    ULONG cbRead, cbWritten, sbHeadOfChain = BLOCK_END_OF_CHAIN;
    DirRef streamEntryRef;
    HRESULT resWrite = S_OK, resRead = S_OK;
    DirEntry streamEntry;
    BYTE* buffer;
    SmallBlockChainStream* sbTempChain;
 
    TRACE("%p %p\n", This, ppbbChain);
 
    sbTempChain = SmallBlockChainStream_Construct(This, &sbHeadOfChain,
            DIRENTRY_NULL);
 
    if(!sbTempChain)
        return NULL;
 
    SmallBlockChainStream_SetSize(sbTempChain, newSize);
    size = BlockChainStream_GetSize(*ppbbChain);
    size.QuadPart = min(size.QuadPart, newSize.QuadPart);
 
    offset.u.HighPart = 0;
    offset.u.LowPart = 0;
    cbTotalRead.QuadPart = 0;
    buffer = HeapAlloc(GetProcessHeap(), 0, This->bigBlockSize);
    while(cbTotalRead.QuadPart < size.QuadPart)
    {
        resRead = BlockChainStream_ReadAt(*ppbbChain, offset,
                min(This->bigBlockSize, size.u.LowPart - offset.u.LowPart),
                buffer, &cbRead);
 
        if(FAILED(resRead))
            break;
 
        if(cbRead > 0)
        {
            cbTotalRead.QuadPart += cbRead;
 
            resWrite = SmallBlockChainStream_WriteAt(sbTempChain, offset,
                    cbRead, buffer, &cbWritten);
 
            if(FAILED(resWrite))
                break;
 
            offset.u.LowPart += cbRead;
        }
        else
        {
            resRead = STG_E_READFAULT;
            break;
        }
    }
    HeapFree(GetProcessHeap(), 0, buffer);
 
    size.u.HighPart = 0;
    size.u.LowPart = 0;
 
    if(FAILED(resRead) || FAILED(resWrite))
    {
        ERR("conversion failed: resRead = 0x%08x, resWrite = 0x%08x\n", resRead, resWrite);
        SmallBlockChainStream_SetSize(sbTempChain, size);
        SmallBlockChainStream_Destroy(sbTempChain);
        return NULL;
    }
 
    /* destroy the original big block chain */
    streamEntryRef = (*ppbbChain)->ownerDirEntry;
    BlockChainStream_SetSize(*ppbbChain, size);
    BlockChainStream_Destroy(*ppbbChain);
    *ppbbChain = NULL;
 
    StorageImpl_ReadDirEntry(This, streamEntryRef, &streamEntry);
    streamEntry.startingBlock = sbHeadOfChain;
    StorageImpl_WriteDirEntry(This, streamEntryRef, &streamEntry);
 
    SmallBlockChainStream_Destroy(sbTempChain);
    return SmallBlockChainStream_Construct(This, NULL, streamEntryRef);
}

Referenced by StorageImpl_StreamSetSize().

Storage32Impl_GetExtDepotBlock()

static ULONG Storage32Impl_GetExtDepotBlock ( StorageImpl *  This, ULONG  depotIndex  )

static

Definition at line 3863 of file storage32.c.

{
  ULONG depotBlocksPerExtBlock = (This->bigBlockSize / sizeof(ULONG)) - 1;
  ULONG numExtBlocks           = depotIndex - COUNT_BBDEPOTINHEADER;
  ULONG extBlockCount          = numExtBlocks / depotBlocksPerExtBlock;
  ULONG extBlockOffset         = numExtBlocks % depotBlocksPerExtBlock;
  ULONG blockIndex             = BLOCK_UNUSED;
  ULONG extBlockIndex;
  BYTE depotBuffer[MAX_BIG_BLOCK_SIZE];
  int index, num_blocks;
 
  assert(depotIndex >= COUNT_BBDEPOTINHEADER);
 
  if (extBlockCount >= This->extBigBlockDepotCount)
    return BLOCK_UNUSED;
 
  if (This->indexExtBlockDepotCached != extBlockCount)
  {
    extBlockIndex = This->extBigBlockDepotLocations[extBlockCount];
 
    StorageImpl_ReadBigBlock(This, extBlockIndex, depotBuffer, NULL);
 
    num_blocks = This->bigBlockSize / 4;
 
    for (index = 0; index < num_blocks; index++)
    {
      StorageUtl_ReadDWord(depotBuffer, index*sizeof(ULONG), &blockIndex);
      This->extBlockDepotCached[index] = blockIndex;
    }
 
    This->indexExtBlockDepotCached = extBlockCount;
  }
 
  blockIndex = This->extBlockDepotCached[extBlockOffset];
 
  return blockIndex;
}

Referenced by StorageImpl_GetNextBlockInChain(), StorageImpl_GetNextFreeBigBlock(), and StorageImpl_SetNextBlockInChain().

Storage32Impl_GetNextExtendedBlock()

static ULONG Storage32Impl_GetNextExtendedBlock ( StorageImpl *  This, ULONG  blockIndex  )

static

Definition at line 4096 of file storage32.c.

{
  ULONG nextBlockIndex   = BLOCK_SPECIAL;
  ULONG depotBlockOffset = This->bigBlockSize - sizeof(ULONG);
 
  StorageImpl_ReadDWordFromBigBlock(This, blockIndex, depotBlockOffset,
                        &nextBlockIndex);
 
  return nextBlockIndex;
}

Referenced by StorageImpl_Refresh().

Storage32Impl_SetExtDepotBlock()

static void Storage32Impl_SetExtDepotBlock ( StorageImpl *  This, ULONG  depotIndex, ULONG  blockIndex  )

static

Definition at line 3908 of file storage32.c.

{
  ULONG depotBlocksPerExtBlock = (This->bigBlockSize / sizeof(ULONG)) - 1;
  ULONG numExtBlocks           = depotIndex - COUNT_BBDEPOTINHEADER;
  ULONG extBlockCount          = numExtBlocks / depotBlocksPerExtBlock;
  ULONG extBlockOffset         = numExtBlocks % depotBlocksPerExtBlock;
  ULONG extBlockIndex;
 
  assert(depotIndex >= COUNT_BBDEPOTINHEADER);
 
  assert(extBlockCount < This->extBigBlockDepotCount);
 
  extBlockIndex = This->extBigBlockDepotLocations[extBlockCount];
 
  if (extBlockIndex != BLOCK_UNUSED)
  {
    StorageImpl_WriteDWordToBigBlock(This, extBlockIndex,
                        extBlockOffset * sizeof(ULONG),
                        blockIndex);
  }
 
  if (This->indexExtBlockDepotCached == extBlockCount)
  {
    This->extBlockDepotCached[extBlockOffset] = blockIndex;
  }
}

Referenced by StorageImpl_GetNextFreeBigBlock().

Storage32Impl_SmallBlocksToBigBlocks()

static BlockChainStream * Storage32Impl_SmallBlocksToBigBlocks ( StorageImpl *  This, SmallBlockChainStream **  ppsbChain  )

static

Definition at line 3626 of file storage32.c.

{
  ULONG bbHeadOfChain = BLOCK_END_OF_CHAIN;
  ULARGE_INTEGER size, offset;
  ULONG cbRead, cbWritten;
  ULARGE_INTEGER cbTotalRead;
  DirRef streamEntryRef;
  HRESULT resWrite = S_OK;
  HRESULT resRead;
  DirEntry streamEntry;
  BYTE *buffer;
  BlockChainStream *bbTempChain = NULL;
  BlockChainStream *bigBlockChain = NULL;
 
  /*
   * Create a temporary big block chain that doesn't have
   * an associated directory entry. This temporary chain will be
   * used to copy data from small blocks to big blocks.
   */
  bbTempChain = BlockChainStream_Construct(This,
                                           &bbHeadOfChain,
                                           DIRENTRY_NULL);
  if(!bbTempChain) return NULL;
  /*
   * Grow the big block chain.
   */
  size = SmallBlockChainStream_GetSize(*ppsbChain);
  BlockChainStream_SetSize(bbTempChain, size);
 
  /*
   * Copy the contents of the small block chain to the big block chain
   * by small block size increments.
   */
  offset.u.LowPart = 0;
  offset.u.HighPart = 0;
  cbTotalRead.QuadPart = 0;
 
  buffer = HeapAlloc(GetProcessHeap(),0,DEF_SMALL_BLOCK_SIZE);
  do
  {
    resRead = SmallBlockChainStream_ReadAt(*ppsbChain,
                                           offset,
                                           min(This->smallBlockSize, size.u.LowPart - offset.u.LowPart),
                                           buffer,
                                           &cbRead);
    if (FAILED(resRead))
        break;
 
    if (cbRead > 0)
    {
        cbTotalRead.QuadPart += cbRead;
 
        resWrite = BlockChainStream_WriteAt(bbTempChain,
                                            offset,
                                            cbRead,
                                            buffer,
                                            &cbWritten);
 
        if (FAILED(resWrite))
            break;
 
        offset.u.LowPart += cbRead;
    }
    else
    {
        resRead = STG_E_READFAULT;
        break;
    }
  } while (cbTotalRead.QuadPart < size.QuadPart);
  HeapFree(GetProcessHeap(),0,buffer);
 
  size.u.HighPart = 0;
  size.u.LowPart  = 0;
 
  if (FAILED(resRead) || FAILED(resWrite))
  {
    ERR("conversion failed: resRead = 0x%08x, resWrite = 0x%08x\n", resRead, resWrite);
    BlockChainStream_SetSize(bbTempChain, size);
    BlockChainStream_Destroy(bbTempChain);
    return NULL;
  }
 
  /*
   * Destroy the small block chain.
   */
  streamEntryRef = (*ppsbChain)->ownerDirEntry;
  SmallBlockChainStream_SetSize(*ppsbChain, size);
  SmallBlockChainStream_Destroy(*ppsbChain);
  *ppsbChain = 0;
 
  /*
   * Change the directory entry. This chain is now a big block chain
   * and it doesn't reside in the small blocks chain anymore.
   */
  StorageImpl_ReadDirEntry(This, streamEntryRef, &streamEntry);
 
  streamEntry.startingBlock = bbHeadOfChain;
 
  StorageImpl_WriteDirEntry(This, streamEntryRef, &streamEntry);
 
  /*
   * Destroy the temporary entryless big block chain.
   * Create a new big block chain associated with this entry.
   */
  BlockChainStream_Destroy(bbTempChain);
  bigBlockChain = BlockChainStream_Construct(This,
                                             NULL,
                                             streamEntryRef);
 
  return bigBlockChain;
}

Referenced by StorageImpl_StreamSetSize().

Storage_Construct()

static HRESULT Storage_Construct ( HANDLE  hFile, LPCOLESTR  pwcsName, ILockBytes *  pLkbyt, DWORD  openFlags, BOOL  fileBased, BOOL  create, ULONG  sector_size, StorageBaseImpl **  result  )

static

Definition at line 6906 of file storage32.c.

{
  StorageImpl *newStorage;
  StorageBaseImpl *newTransactedStorage;
  HRESULT hr;
 
  hr = StorageImpl_Construct(hFile, pwcsName, pLkbyt, openFlags, fileBased, create, sector_size, &newStorage);
  if (FAILED(hr)) goto end;
 
  if (openFlags & STGM_TRANSACTED)
  {
    hr = Storage_ConstructTransacted(&newStorage->base, TRUE, &newTransactedStorage);
    if (FAILED(hr))
      IStorage_Release(&newStorage->base.IStorage_iface);
    else
      *result = newTransactedStorage;
  }
  else
    *result = &newStorage->base;
 
end:
  return hr;
}

Referenced by create_storagefile(), StgCreateDocfileOnILockBytes(), StgOpenStorage(), and StgOpenStorageOnILockBytes().

Storage_ConstructTransacted()

static HRESULT Storage_ConstructTransacted ( StorageBaseImpl *  parentStorage, BOOL  toplevel, StorageBaseImpl **  result  )

static

Definition at line 6883 of file storage32.c.

{
  static int fixme_flags=STGM_NOSCRATCH|STGM_NOSNAPSHOT;
 
  if (parentStorage->openFlags & fixme_flags)
  {
    fixme_flags &= ~parentStorage->openFlags;
    FIXME("Unimplemented flags %x\n", parentStorage->openFlags);
  }
 
  if (toplevel && !(parentStorage->openFlags & STGM_NOSNAPSHOT) &&
      STGM_SHARE_MODE(parentStorage->openFlags) != STGM_SHARE_DENY_WRITE &&
      STGM_SHARE_MODE(parentStorage->openFlags) != STGM_SHARE_EXCLUSIVE)
  {
    /* Need to create a temp file for the snapshot */
    return TransactedSharedImpl_Construct(parentStorage, (TransactedSharedImpl**)result);
  }
 
  return TransactedSnapshotImpl_Construct(parentStorage,
    (TransactedSnapshotImpl**)result);
}

Referenced by Storage_Construct(), and StorageBaseImpl_OpenStorage().

STORAGE_CreateOleStream()

HRESULT STORAGE_CreateOleStream	(	IStorage *	storage,
		DWORD	flags
	)

Definition at line 9207 of file storage32.c.

{
    static const WCHAR stream_1oleW[] = {1,'O','l','e',0};
    static const DWORD version_magic = 0x02000001;
    IStream *stream;
    HRESULT hr;
 
    hr = IStorage_CreateStream(storage, stream_1oleW, STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stream);
    if (hr == S_OK)
    {
        struct empty_1ole_stream {
            DWORD version_magic;
            DWORD flags;
            DWORD update_options;
            DWORD reserved;
            DWORD mon_stream_size;
        };
        struct empty_1ole_stream stream_data;
 
        stream_data.version_magic = version_magic;
        stream_data.flags = flags;
        stream_data.update_options = 0;
        stream_data.reserved = 0;
        stream_data.mon_stream_size = 0;
 
        hr = IStream_Write(stream, &stream_data, sizeof(stream_data), NULL);
        IStream_Release(stream);
    }
 
    return hr;
}

Referenced by DefaultHandler_IPersistStorage_InitNew(), load_ole_stream(), OleConvertOLESTREAMToIStorage(), render_embed_source_hack(), and SetConvertStg().

STORAGE_WriteCompObj()

static HRESULT STORAGE_WriteCompObj ( LPSTORAGE  pstg, CLSID *  clsid, LPCWSTR  lpszUserType, LPCWSTR  szClipName, LPCWSTR  szProgIDName  )

static

Definition at line 9309 of file storage32.c.

{
    IStream *pstm;
    HRESULT r = S_OK;
    static const WCHAR szwStreamName[] = {1, 'C', 'o', 'm', 'p', 'O', 'b', 'j', 0};
 
    static const BYTE unknown1[12] =
       { 0x01, 0x00, 0xFE, 0xFF, 0x03, 0x0A, 0x00, 0x00,
         0xFF, 0xFF, 0xFF, 0xFF};
    static const BYTE unknown2[16] =
       { 0xF4, 0x39, 0xB2, 0x71, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 
    TRACE("%p %s %s %s %s\n", pstg, debugstr_guid(clsid),
           debugstr_w(lpszUserType), debugstr_w(szClipName),
           debugstr_w(szProgIDName));
 
    /*  Create a CompObj stream */
    r = IStorage_CreateStream(pstg, szwStreamName,
        STGM_CREATE | STGM_WRITE  | STGM_SHARE_EXCLUSIVE, 0, 0, &pstm );
    if( FAILED (r) )
        return r;
 
    /* Write CompObj Structure to stream */
    r = IStream_Write(pstm, unknown1, sizeof(unknown1), NULL);
 
    if( SUCCEEDED( r ) )
        r = WriteClassStm( pstm, clsid );
 
    if( SUCCEEDED( r ) )
        r = STREAM_WriteString( pstm, lpszUserType );
    if( SUCCEEDED( r ) )
        r = STREAM_WriteString( pstm, szClipName );
    if( SUCCEEDED( r ) )
        r = STREAM_WriteString( pstm, szProgIDName );
    if( SUCCEEDED( r ) )
        r = IStream_Write(pstm, unknown2, sizeof(unknown2), NULL);
 
    IStream_Release( pstm );
 
    return r;
}

Referenced by WriteFmtUserTypeStg().

StorageBaseImpl_AddRef()

static ULONG WINAPI StorageBaseImpl_AddRef ( IStorage *  iface )

static

Definition at line 1279 of file storage32.c.

{
  StorageBaseImpl *This = impl_from_IStorage(iface);
  ULONG ref = InterlockedIncrement(&This->ref);
 
  TRACE("(%p) AddRef to %d\n", This, ref);
 
  return ref;
}

StorageBaseImpl_AddStream()

void StorageBaseImpl_AddStream	(	StorageBaseImpl *	stg,
		StgStreamImpl *	strm
	)

Definition at line 2714 of file storage32.c.

{
  TRACE("Stream added (stg=%p strm=%p)\n", stg, strm);
  list_add_tail(&stg->strmHead,&strm->StrmListEntry);
}

Referenced by StgStreamImpl_Construct().

StorageBaseImpl_Commit()

static HRESULT WINAPI StorageBaseImpl_Commit ( IStorage *  iface, DWORD  grfCommitFlags  )

static

Definition at line 2398 of file storage32.c.

{
  StorageBaseImpl* This = impl_from_IStorage(iface);
  TRACE("(%p %d)\n", iface, grfCommitFlags);
  return StorageBaseImpl_Flush(This);
}

StorageBaseImpl_CopyChildEntryTo()

static HRESULT StorageBaseImpl_CopyChildEntryTo ( StorageBaseImpl *  This, DirRef  srcEntry, BOOL  skip_storage, BOOL  skip_stream, SNB  snbExclude, IStorage *  pstgDest  )

static

Definition at line 1324 of file storage32.c.

{
  DirEntry data;
  HRESULT hr;
  BOOL skip = FALSE;
  IStorage *pstgTmp;
  IStream *pstrChild, *pstrTmp;
  STATSTG strStat;
 
  if (srcEntry == DIRENTRY_NULL)
    return S_OK;
 
  hr = StorageBaseImpl_ReadDirEntry( This, srcEntry, &data );
 
  if (FAILED(hr))
    return hr;
 
  if ( snbExclude )
  {
    WCHAR **snb = snbExclude;
 
    while ( *snb != NULL && !skip )
    {
      if ( wcscmp(data.name, *snb) == 0 )
        skip = TRUE;
      ++snb;
    }
  }
 
  if (!skip)
  {
    if (data.stgType == STGTY_STORAGE && !skip_storage)
    {
      /*
       * create a new storage in destination storage
       */
      hr = IStorage_CreateStorage( pstgDest, data.name,
                                   STGM_FAILIFTHERE|STGM_WRITE|STGM_SHARE_EXCLUSIVE,
                                   0, 0,
                                   &pstgTmp );
 
      /*
       * if it already exist, don't create a new one use this one
       */
      if (hr == STG_E_FILEALREADYEXISTS)
      {
        hr = IStorage_OpenStorage( pstgDest, data.name, NULL,
                                   STGM_WRITE|STGM_SHARE_EXCLUSIVE,
                                   NULL, 0, &pstgTmp );
      }
 
      if (SUCCEEDED(hr))
      {
        hr = StorageBaseImpl_CopyStorageEntryTo( This, srcEntry, skip_storage,
                                                 skip_stream, NULL, pstgTmp );
 
        IStorage_Release(pstgTmp);
      }
    }
    else if (data.stgType == STGTY_STREAM && !skip_stream)
    {
      /*
       * create a new stream in destination storage. If the stream already
       * exist, it will be deleted and a new one will be created.
       */
      hr = IStorage_CreateStream( pstgDest, data.name,
                                  STGM_CREATE|STGM_WRITE|STGM_SHARE_EXCLUSIVE,
                                  0, 0, &pstrTmp );
 
      /*
       * open child stream storage. This operation must succeed even if the
       * stream is already open, so we use internal functions to do it.
       */
      if (hr == S_OK)
      {
        StgStreamImpl *streamimpl = StgStreamImpl_Construct(This, STGM_READ|STGM_SHARE_EXCLUSIVE, srcEntry);
 
        if (streamimpl)
        {
          pstrChild = &streamimpl->IStream_iface;
          if (pstrChild)
            IStream_AddRef(pstrChild);
        }
        else
        {
          pstrChild = NULL;
          hr = E_OUTOFMEMORY;
        }
      }
 
      if (hr == S_OK)
      {
        /*
         * Get the size of the source stream
         */
        IStream_Stat( pstrChild, &strStat, STATFLAG_NONAME );
 
        /*
         * Set the size of the destination stream.
         */
        IStream_SetSize(pstrTmp, strStat.cbSize);
 
        /*
         * do the copy
         */
        hr = IStream_CopyTo( pstrChild, pstrTmp, strStat.cbSize,
                             NULL, NULL );
 
        IStream_Release( pstrChild );
      }
 
      IStream_Release( pstrTmp );
    }
  }
 
  /* copy siblings */
  if (SUCCEEDED(hr))
    hr = StorageBaseImpl_CopyChildEntryTo( This, data.leftChild, skip_storage,
                                           skip_stream, snbExclude, pstgDest );
 
  if (SUCCEEDED(hr))
    hr = StorageBaseImpl_CopyChildEntryTo( This, data.rightChild, skip_storage,
                                           skip_stream, snbExclude, pstgDest );
 
  TRACE("<-- %08x\n", hr);
  return hr;
}

Referenced by StorageBaseImpl_CopyChildEntryTo(), and StorageBaseImpl_CopyStorageEntryTo().

StorageBaseImpl_CopyStorageEntryTo()

static HRESULT StorageBaseImpl_CopyStorageEntryTo ( StorageBaseImpl *  This, DirRef  srcEntry, BOOL  skip_storage, BOOL  skip_stream, SNB  snbExclude, IStorage *  pstgDest  )

static

Definition at line 2265 of file storage32.c.

{
  DirEntry data;
  HRESULT hr;
 
  hr = StorageBaseImpl_ReadDirEntry( This, srcEntry, &data );
 
  if (SUCCEEDED(hr))
    hr = IStorage_SetClass( pstgDest, &data.clsid );
 
  if (SUCCEEDED(hr))
    hr = StorageBaseImpl_CopyChildEntryTo( This, data.dirRootEntry, skip_storage,
      skip_stream, snbExclude, pstgDest );
 
  TRACE("<-- %08x\n", hr);
  return hr;
}

Referenced by StorageBaseImpl_CopyChildEntryTo(), and StorageBaseImpl_CopyTo().

StorageBaseImpl_CopyStorageTree()

static HRESULT StorageBaseImpl_CopyStorageTree ( StorageBaseImpl *  dst, DirRef  dst_entry, StorageBaseImpl *  src, DirRef  src_entry  )

static

Definition at line 2804 of file storage32.c.

{
  HRESULT hr;
  DirEntry src_data, dst_data;
  DirRef new_root_entry;
 
  hr = StorageBaseImpl_ReadDirEntry(src, src_entry, &src_data);
 
  if (SUCCEEDED(hr))
  {
    hr = StorageBaseImpl_DupStorageTree(dst, &new_root_entry, src, src_data.dirRootEntry);
  }
 
  if (SUCCEEDED(hr))
  {
    hr = StorageBaseImpl_ReadDirEntry(dst, dst_entry, &dst_data);
    dst_data.clsid = src_data.clsid;
    dst_data.ctime = src_data.ctime;
    dst_data.mtime = src_data.mtime;
    dst_data.dirRootEntry = new_root_entry;
  }
 
  if (SUCCEEDED(hr))
    hr = StorageBaseImpl_WriteDirEntry(dst, dst_entry, &dst_data);
 
  return hr;
}

Referenced by TransactedSharedImpl_Construct().

StorageBaseImpl_CopyStream()

static HRESULT StorageBaseImpl_CopyStream ( StorageBaseImpl *  dst, DirRef  dst_entry, StorageBaseImpl *  src, DirRef  src_entry  )

static

Definition at line 2726 of file storage32.c.

{
  HRESULT hr;
  BYTE data[4096];
  DirEntry srcdata;
  ULARGE_INTEGER bytes_copied;
  ULONG bytestocopy, bytesread, byteswritten;
 
  hr = StorageBaseImpl_ReadDirEntry(src, src_entry, &srcdata);
 
  if (SUCCEEDED(hr))
  {
    hr = StorageBaseImpl_StreamSetSize(dst, dst_entry, srcdata.size);
 
    bytes_copied.QuadPart = 0;
    while (bytes_copied.QuadPart < srcdata.size.QuadPart && SUCCEEDED(hr))
    {
      bytestocopy = min(4096, srcdata.size.QuadPart - bytes_copied.QuadPart);
 
      hr = StorageBaseImpl_StreamReadAt(src, src_entry, bytes_copied, bytestocopy,
        data, &bytesread);
      if (SUCCEEDED(hr) && bytesread != bytestocopy) hr = STG_E_READFAULT;
 
      if (SUCCEEDED(hr))
        hr = StorageBaseImpl_StreamWriteAt(dst, dst_entry, bytes_copied, bytestocopy,
          data, &byteswritten);
      if (SUCCEEDED(hr))
      {
        if (byteswritten != bytestocopy) hr = STG_E_WRITEFAULT;
        bytes_copied.QuadPart += byteswritten;
      }
    }
  }
 
  return hr;
}

Referenced by StorageBaseImpl_DupStorageTree(), TransactedSnapshotImpl_CopyTree(), and TransactedSnapshotImpl_MakeStreamDirty().

StorageBaseImpl_CopyTo()

static HRESULT WINAPI StorageBaseImpl_CopyTo ( IStorage *  iface, DWORD  ciidExclude, const IID *  rgiidExclude, SNB  snbExclude, IStorage *  pstgDest  )

static

Definition at line 2288 of file storage32.c.

{
  StorageBaseImpl *This = impl_from_IStorage(iface);
 
  BOOL         skip_storage = FALSE, skip_stream = FALSE;
  DWORD        i;
 
  TRACE("(%p, %d, %p, %p, %p)\n",
    iface, ciidExclude, rgiidExclude,
    snbExclude, pstgDest);
 
  if ( pstgDest == 0 )
    return STG_E_INVALIDPOINTER;
 
  for(i = 0; i < ciidExclude; ++i)
  {
    if(IsEqualGUID(&IID_IStorage, &rgiidExclude[i]))
        skip_storage = TRUE;
    else if(IsEqualGUID(&IID_IStream, &rgiidExclude[i]))
        skip_stream = TRUE;
    else
        WARN("Unknown excluded GUID: %s\n", debugstr_guid(&rgiidExclude[i]));
  }
 
  if (!skip_storage)
  {
    /* Give up early if it looks like this would be infinitely recursive.
     * Oddly enough, this includes some cases that aren't really recursive, like
     * copying to a transacted child. */
    IStorage *pstgDestAncestor = pstgDest;
    IStorage *pstgDestAncestorChild = NULL;
 
    /* Go up the chain from the destination until we find the source storage. */
    while (pstgDestAncestor != iface) {
      pstgDestAncestorChild = pstgDest;
 
      if (pstgDestAncestor->lpVtbl == &TransactedSnapshotImpl_Vtbl)
      {
        TransactedSnapshotImpl *snapshot = (TransactedSnapshotImpl*) pstgDestAncestor;
 
        pstgDestAncestor = &snapshot->transactedParent->IStorage_iface;
      }
      else if (pstgDestAncestor->lpVtbl == &StorageInternalImpl_Vtbl)
      {
        StorageInternalImpl *internal = (StorageInternalImpl*) pstgDestAncestor;
 
        pstgDestAncestor = &internal->parentStorage->IStorage_iface;
      }
      else
        break;
    }
 
    if (pstgDestAncestor == iface)
    {
      BOOL fail = TRUE;
 
      if (pstgDestAncestorChild && snbExclude)
      {
        StorageBaseImpl *ancestorChildBase = (StorageBaseImpl*)pstgDestAncestorChild;
        DirEntry data;
        WCHAR **snb = snbExclude;
 
        StorageBaseImpl_ReadDirEntry(ancestorChildBase, ancestorChildBase->storageDirEntry, &data);
 
        while ( *snb != NULL && fail )
        {
          if ( wcscmp(data.name, *snb) == 0 )
            fail = FALSE;
          ++snb;
        }
      }
 
      if (fail)
        return STG_E_ACCESSDENIED;
    }
  }
 
  return StorageBaseImpl_CopyStorageEntryTo( This, This->storageDirEntry,
    skip_storage, skip_stream, snbExclude, pstgDest );
}

StorageBaseImpl_CreateStorage()

static HRESULT WINAPI StorageBaseImpl_CreateStorage ( IStorage *  iface, const OLECHAR *  pwcsName, DWORD  grfMode, DWORD  reserved1, DWORD  reserved2, IStorage **  ppstg  )

static

Definition at line 2117 of file storage32.c.

{
  StorageBaseImpl* This = impl_from_IStorage(iface);
 
  DirEntry         currentEntry;
  DirEntry         newEntry;
  DirRef           currentEntryRef;
  DirRef           newEntryRef;
  HRESULT          hr;
 
  TRACE("(%p, %s, %x, %d, %d, %p)\n",
    iface, debugstr_w(pwcsName), grfMode,
    reserved1, reserved2, ppstg);
 
  if (ppstg == 0)
    return STG_E_INVALIDPOINTER;
 
  if (This->openFlags & STGM_SIMPLE)
  {
    return STG_E_INVALIDFUNCTION;
  }
 
  if (pwcsName == 0)
    return STG_E_INVALIDNAME;
 
  *ppstg = NULL;
 
  if ( FAILED( validateSTGM(grfMode) ) ||
       (grfMode & STGM_DELETEONRELEASE) )
  {
    WARN("bad grfMode: 0x%x\n", grfMode);
    return STG_E_INVALIDFLAG;
  }
 
  if (This->reverted)
    return STG_E_REVERTED;
 
  /*
   * Check that we're compatible with the parent's storage mode
   */
  if ( !(This->openFlags & STGM_TRANSACTED) &&
       STGM_ACCESS_MODE( grfMode ) > STGM_ACCESS_MODE( This->openFlags ) )
  {
    WARN("access denied\n");
    return STG_E_ACCESSDENIED;
  }
 
  currentEntryRef = findElement(This,
                                   This->storageDirEntry,
                                   pwcsName,
                                   &currentEntry);
 
  if (currentEntryRef != DIRENTRY_NULL)
  {
    /*
     * An element with this name already exists
     */
    if (STGM_CREATE_MODE(grfMode) == STGM_CREATE &&
        ((This->openFlags & STGM_TRANSACTED) ||
         STGM_ACCESS_MODE(This->openFlags) != STGM_READ))
    {
      hr = IStorage_DestroyElement(iface, pwcsName);
      if (FAILED(hr))
        return hr;
    }
    else
    {
      WARN("file already exists\n");
      return STG_E_FILEALREADYEXISTS;
    }
  }
  else if (!(This->openFlags & STGM_TRANSACTED) &&
           STGM_ACCESS_MODE(This->openFlags) == STGM_READ)
  {
    WARN("read-only storage\n");
    return STG_E_ACCESSDENIED;
  }
 
  memset(&newEntry, 0, sizeof(DirEntry));
 
  newEntry.sizeOfNameString = (lstrlenW(pwcsName)+1)*sizeof(WCHAR);
 
  if (newEntry.sizeOfNameString > DIRENTRY_NAME_BUFFER_LEN)
  {
    FIXME("name too long\n");
    return STG_E_INVALIDNAME;
  }
 
  lstrcpyW(newEntry.name, pwcsName);
 
  newEntry.stgType       = STGTY_STORAGE;
  newEntry.startingBlock = BLOCK_END_OF_CHAIN;
  newEntry.size.u.LowPart  = 0;
  newEntry.size.u.HighPart = 0;
 
  newEntry.leftChild        = DIRENTRY_NULL;
  newEntry.rightChild       = DIRENTRY_NULL;
  newEntry.dirRootEntry     = DIRENTRY_NULL;
 
  /* call CoFileTime to get the current time
  newEntry.ctime
  newEntry.mtime
  */
 
  /*  newEntry.clsid */
 
  /*
   * Create a new directory entry for the storage
   */
  hr = StorageBaseImpl_CreateDirEntry(This, &newEntry, &newEntryRef);
  if (FAILED(hr))
    return hr;
 
  /*
   * Insert the new directory entry into the parent storage's tree
   */
  hr = insertIntoTree(
    This,
    This->storageDirEntry,
    newEntryRef);
  if (FAILED(hr))
  {
    StorageBaseImpl_DestroyDirEntry(This, newEntryRef);
    return hr;
  }
 
  /*
   * Open it to get a pointer to return.
   */
  hr = IStorage_OpenStorage(iface, pwcsName, 0, grfMode, 0, 0, ppstg);
 
  if( (hr != S_OK) || (*ppstg == NULL))
  {
    return hr;
  }
 
  if (SUCCEEDED(hr))
    hr = StorageBaseImpl_Flush(This);
 
  return S_OK;
}

StorageBaseImpl_CreateStream()

static HRESULT WINAPI StorageBaseImpl_CreateStream ( IStorage *  iface, const OLECHAR *  pwcsName, DWORD  grfMode, DWORD  reserved1, DWORD  reserved2, IStream **  ppstm  )

static

Definition at line 1924 of file storage32.c.

{
  StorageBaseImpl *This = impl_from_IStorage(iface);
  StgStreamImpl*    newStream;
  DirEntry          currentEntry, newStreamEntry;
  DirRef            currentEntryRef, newStreamEntryRef;
  HRESULT hr;
 
  TRACE("(%p, %s, %x, %d, %d, %p)\n",
    iface, debugstr_w(pwcsName), grfMode,
    reserved1, reserved2, ppstm);
 
  if (ppstm == 0)
    return STG_E_INVALIDPOINTER;
 
  if (pwcsName == 0)
    return STG_E_INVALIDNAME;
 
  if (reserved1 || reserved2)
    return STG_E_INVALIDPARAMETER;
 
  if ( FAILED( validateSTGM(grfMode) ))
    return STG_E_INVALIDFLAG;
 
  if (STGM_SHARE_MODE(grfMode) != STGM_SHARE_EXCLUSIVE)
    return STG_E_INVALIDFLAG;
 
  if (This->reverted)
    return STG_E_REVERTED;
 
  /*
   * As documented.
   */
  if ((grfMode & STGM_DELETEONRELEASE) ||
      (grfMode & STGM_TRANSACTED))
    return STG_E_INVALIDFUNCTION;
 
  /*
   * Don't worry about permissions in transacted mode, as we can always write
   * changes; we just can't always commit them.
   */
  if(!(This->openFlags & STGM_TRANSACTED)) {
    /* Can't create a stream on read-only storage */
    if ( STGM_ACCESS_MODE( This->openFlags ) == STGM_READ )
      return STG_E_ACCESSDENIED;
 
    /* Can't create a stream with greater access than the parent. */
    if ( STGM_ACCESS_MODE( grfMode ) > STGM_ACCESS_MODE( This->openFlags ) )
      return STG_E_ACCESSDENIED;
  }
 
  if(This->openFlags & STGM_SIMPLE)
    if(grfMode & STGM_CREATE) return STG_E_INVALIDFLAG;
 
  *ppstm = 0;
 
  currentEntryRef = findElement(This,
                                   This->storageDirEntry,
                                   pwcsName,
                                   &currentEntry);
 
  if (currentEntryRef != DIRENTRY_NULL)
  {
    /*
     * An element with this name already exists
     */
    if (STGM_CREATE_MODE(grfMode) == STGM_CREATE)
    {
      IStorage_DestroyElement(iface, pwcsName);
    }
    else
      return STG_E_FILEALREADYEXISTS;
  }
 
  /*
   * memset the empty entry
   */
  memset(&newStreamEntry, 0, sizeof(DirEntry));
 
  newStreamEntry.sizeOfNameString =
      ( lstrlenW(pwcsName)+1 ) * sizeof(WCHAR);
 
  if (newStreamEntry.sizeOfNameString > DIRENTRY_NAME_BUFFER_LEN)
    return STG_E_INVALIDNAME;
 
  lstrcpyW(newStreamEntry.name, pwcsName);
 
  newStreamEntry.stgType       = STGTY_STREAM;
  newStreamEntry.startingBlock = BLOCK_END_OF_CHAIN;
  newStreamEntry.size.u.LowPart  = 0;
  newStreamEntry.size.u.HighPart = 0;
 
  newStreamEntry.leftChild        = DIRENTRY_NULL;
  newStreamEntry.rightChild       = DIRENTRY_NULL;
  newStreamEntry.dirRootEntry     = DIRENTRY_NULL;
 
  /* call CoFileTime to get the current time
  newStreamEntry.ctime
  newStreamEntry.mtime
  */
 
  /*  newStreamEntry.clsid */
 
  /*
   * Create an entry with the new data
   */
  hr = StorageBaseImpl_CreateDirEntry(This, &newStreamEntry, &newStreamEntryRef);
  if (FAILED(hr))
    return hr;
 
  /*
   * Insert the new entry in the parent storage's tree.
   */
  hr = insertIntoTree(
    This,
    This->storageDirEntry,
    newStreamEntryRef);
  if (FAILED(hr))
  {
    StorageBaseImpl_DestroyDirEntry(This, newStreamEntryRef);
    return hr;
  }
 
  /*
   * Open the stream to return it.
   */
  newStream = StgStreamImpl_Construct(This, grfMode, newStreamEntryRef);
 
  if (newStream)
  {
    *ppstm = &newStream->IStream_iface;
    IStream_AddRef(*ppstm);
  }
  else
  {
    return STG_E_INSUFFICIENTMEMORY;
  }
 
  return StorageBaseImpl_Flush(This);
}

StorageBaseImpl_DeleteAll()

static void StorageBaseImpl_DeleteAll ( StorageBaseImpl *  stg )

static

Definition at line 2653 of file storage32.c.

{
  struct list *cur, *cur2;
  StgStreamImpl *strm=NULL;
  StorageInternalImpl *childstg=NULL;
 
  LIST_FOR_EACH_SAFE(cur, cur2, &stg->strmHead) {
    strm = LIST_ENTRY(cur,StgStreamImpl,StrmListEntry);
    TRACE("Streams invalidated (stg=%p strm=%p next=%p prev=%p)\n", stg,strm,cur->next,cur->prev);
    strm->parentStorage = NULL;
    list_remove(cur);
  }
 
  LIST_FOR_EACH_SAFE(cur, cur2, &stg->storageHead) {
    childstg = LIST_ENTRY(cur,StorageInternalImpl,ParentListEntry);
    StorageBaseImpl_Invalidate( &childstg->base );
  }
 
  if (stg->transactedChild)
  {
    StorageBaseImpl_Invalidate(stg->transactedChild);
 
    stg->transactedChild = NULL;
  }
}

Referenced by StorageImpl_Invalidate(), StorageInternalImpl_Invalidate(), TransactedSharedImpl_Invalidate(), TransactedSharedImpl_Revert(), TransactedSnapshotImpl_Invalidate(), and TransactedSnapshotImpl_Revert().

StorageBaseImpl_DeleteStorageTree()

static HRESULT StorageBaseImpl_DeleteStorageTree ( StorageBaseImpl *  This, DirRef  entry, BOOL  include_siblings  )

static

Definition at line 2834 of file storage32.c.

{
  HRESULT hr;
  DirEntry data;
  ULARGE_INTEGER zero;
 
  if (entry == DIRENTRY_NULL)
    return S_OK;
 
  zero.QuadPart = 0;
 
  hr = StorageBaseImpl_ReadDirEntry(This, entry, &data);
 
  if (SUCCEEDED(hr) && include_siblings)
    hr = StorageBaseImpl_DeleteStorageTree(This, data.leftChild, TRUE);
 
  if (SUCCEEDED(hr) && include_siblings)
    hr = StorageBaseImpl_DeleteStorageTree(This, data.rightChild, TRUE);
 
  if (SUCCEEDED(hr))
    hr = StorageBaseImpl_DeleteStorageTree(This, data.dirRootEntry, TRUE);
 
  if (SUCCEEDED(hr) && data.stgType == STGTY_STREAM)
    hr = StorageBaseImpl_StreamSetSize(This, entry, zero);
 
  if (SUCCEEDED(hr))
    hr = StorageBaseImpl_DestroyDirEntry(This, entry);
 
  return hr;
}

Referenced by StorageBaseImpl_DeleteStorageTree(), and TransactedSharedImpl_Commit().

StorageBaseImpl_DestroyElement()

static HRESULT WINAPI StorageBaseImpl_DestroyElement ( IStorage *  iface, const OLECHAR *  pwcsName  )

static

Definition at line 2576 of file storage32.c.

{
  StorageBaseImpl *This = impl_from_IStorage(iface);
 
  HRESULT           hr = S_OK;
  DirEntry          entryToDelete;
  DirRef            entryToDeleteRef;
 
  TRACE("(%p, %s)\n",
    iface, debugstr_w(pwcsName));
 
  if (pwcsName==NULL)
    return STG_E_INVALIDPOINTER;
 
  if (This->reverted)
    return STG_E_REVERTED;
 
  if ( !(This->openFlags & STGM_TRANSACTED) &&
       STGM_ACCESS_MODE( This->openFlags ) == STGM_READ )
    return STG_E_ACCESSDENIED;
 
  entryToDeleteRef = findElement(
    This,
    This->storageDirEntry,
    pwcsName,
    &entryToDelete);
 
  if ( entryToDeleteRef == DIRENTRY_NULL )
  {
    TRACE("<-- STG_E_FILENOTFOUND\n");
    return STG_E_FILENOTFOUND;
  }
 
  if ( entryToDelete.stgType == STGTY_STORAGE )
  {
    hr = deleteStorageContents(
           This,
           entryToDeleteRef,
           entryToDelete);
  }
  else if ( entryToDelete.stgType == STGTY_STREAM )
  {
    hr = deleteStreamContents(
           This,
           entryToDeleteRef,
           entryToDelete);
  }
 
  if (hr!=S_OK)
  {
    TRACE("<-- %08x\n", hr);
    return hr;
  }
 
  /*
   * Remove the entry from its parent storage
   */
  hr = removeFromTree(
        This,
        This->storageDirEntry,
        entryToDeleteRef);
 
  /*
   * Invalidate the entry
   */
  if (SUCCEEDED(hr))
    StorageBaseImpl_DestroyDirEntry(This, entryToDeleteRef);
 
  if (SUCCEEDED(hr))
    hr = StorageBaseImpl_Flush(This);
 
  TRACE("<-- %08x\n", hr);
  return hr;
}

StorageBaseImpl_DupStorageTree()

static HRESULT StorageBaseImpl_DupStorageTree ( StorageBaseImpl *  dst, DirRef *  dst_entry, StorageBaseImpl *  src, DirRef  src_entry  )

static

Definition at line 2765 of file storage32.c.

{
  HRESULT hr;
  DirEntry data;
  BOOL has_stream=FALSE;
 
  if (src_entry == DIRENTRY_NULL)
  {
    *dst_entry = DIRENTRY_NULL;
    return S_OK;
  }
 
  hr = StorageBaseImpl_ReadDirEntry(src, src_entry, &data);
  if (SUCCEEDED(hr))
  {
    has_stream = (data.stgType == STGTY_STREAM && data.size.QuadPart != 0);
    data.startingBlock = BLOCK_END_OF_CHAIN;
    data.size.QuadPart = 0;
 
    hr = StorageBaseImpl_DupStorageTree(dst, &data.leftChild, src, data.leftChild);
  }
 
  if (SUCCEEDED(hr))
    hr = StorageBaseImpl_DupStorageTree(dst, &data.rightChild, src, data.rightChild);
 
  if (SUCCEEDED(hr))
    hr = StorageBaseImpl_DupStorageTree(dst, &data.dirRootEntry, src, data.dirRootEntry);
 
  if (SUCCEEDED(hr))
    hr = StorageBaseImpl_CreateDirEntry(dst, &data, dst_entry);
 
  if (SUCCEEDED(hr) && has_stream)
    hr = StorageBaseImpl_CopyStream(dst, *dst_entry, src, src_entry);
 
  return hr;
}

Referenced by StorageBaseImpl_CopyStorageTree(), StorageBaseImpl_DupStorageTree(), and TransactedSharedImpl_Commit().

StorageBaseImpl_EnumElements()

static HRESULT WINAPI StorageBaseImpl_EnumElements ( IStorage *  iface, DWORD  reserved1, void *  reserved2, DWORD  reserved3, IEnumSTATSTG **  ppenum  )

static

Definition at line 1747 of file storage32.c.

{
  StorageBaseImpl *This = impl_from_IStorage(iface);
  IEnumSTATSTGImpl* newEnum;
 
  TRACE("(%p, %d, %p, %d, %p)\n",
    iface, reserved1, reserved2, reserved3, ppenum);
 
  if (!ppenum)
    return E_INVALIDARG;
 
  if (This->reverted)
    return STG_E_REVERTED;
 
  newEnum = IEnumSTATSTGImpl_Construct(
              This,
              This->storageDirEntry);
 
  if (newEnum)
  {
    *ppenum = &newEnum->IEnumSTATSTG_iface;
    return S_OK;
  }
 
  return E_OUTOFMEMORY;
}

StorageBaseImpl_IsStorageOpen()

static BOOL StorageBaseImpl_IsStorageOpen ( StorageBaseImpl *  stg, DirRef  storageEntry  )

static

Definition at line 1471 of file storage32.c.

{
  StorageInternalImpl *childstg;
 
  TRACE("%p,%d\n", stg, storageEntry);
 
  LIST_FOR_EACH_ENTRY(childstg, &stg->storageHead, StorageInternalImpl, ParentListEntry)
  {
    if (childstg->base.storageDirEntry == storageEntry)
    {
      return TRUE;
    }
  }
 
  return FALSE;
}

Referenced by StorageBaseImpl_OpenStorage(), and StorageBaseImpl_RenameElement().

StorageBaseImpl_IsStreamOpen()

static BOOL StorageBaseImpl_IsStreamOpen ( StorageBaseImpl *  stg, DirRef  streamEntry  )

static

Definition at line 1454 of file storage32.c.

{
  StgStreamImpl *strm;
 
  TRACE("%p,%d\n", stg, streamEntry);
 
  LIST_FOR_EACH_ENTRY(strm, &stg->strmHead, StgStreamImpl, StrmListEntry)
  {
    if (strm->dirEntry == streamEntry)
    {
      return TRUE;
    }
  }
 
  return FALSE;
}

Referenced by StorageBaseImpl_OpenStream(), and StorageBaseImpl_RenameElement().

StorageBaseImpl_MoveElementTo()

static HRESULT WINAPI StorageBaseImpl_MoveElementTo ( IStorage *  iface, const OLECHAR *  pwcsName, IStorage *  pstgDest, const OLECHAR *  pwcsNewName, DWORD  grfFlags  )

static

Definition at line 2377 of file storage32.c.

{
  FIXME("(%p %s %p %s %u): stub\n", iface,
         debugstr_w(pwcsName), pstgDest,
         debugstr_w(pwcsNewName), grfFlags);
  return E_NOTIMPL;
}

StorageBaseImpl_OpenStorage()

static HRESULT WINAPI StorageBaseImpl_OpenStorage ( IStorage *  iface, const OLECHAR *  pwcsName, IStorage *  pstgPriority, DWORD  grfMode, SNB  snbExclude, DWORD  reserved, IStorage **  ppstg  )

static

Definition at line 1609 of file storage32.c.

{
  StorageBaseImpl *This = impl_from_IStorage(iface);
  StorageInternalImpl*   newStorage;
  StorageBaseImpl*       newTransactedStorage;
  DirEntry               currentEntry;
  DirRef                 storageEntryRef;
  HRESULT                res = STG_E_UNKNOWN;
 
  TRACE("(%p, %s, %p, %x, %p, %d, %p)\n",
    iface, debugstr_w(pwcsName), pstgPriority,
    grfMode, snbExclude, reserved, ppstg);
 
  if ((pwcsName==NULL) || (ppstg==0) )
  {
    res = E_INVALIDARG;
    goto end;
  }
 
  if (This->openFlags & STGM_SIMPLE)
  {
    res = STG_E_INVALIDFUNCTION;
    goto end;
  }
 
  /* as documented */
  if (snbExclude != NULL)
  {
    res = STG_E_INVALIDPARAMETER;
    goto end;
  }
 
  if ( FAILED( validateSTGM(grfMode) ))
  {
    res = STG_E_INVALIDFLAG;
    goto end;
  }
 
  /*
   * As documented.
   */
  if ( STGM_SHARE_MODE(grfMode) != STGM_SHARE_EXCLUSIVE ||
        (grfMode & STGM_DELETEONRELEASE) ||
        (grfMode & STGM_PRIORITY) )
  {
    res = STG_E_INVALIDFUNCTION;
    goto end;
  }
 
  if (This->reverted)
    return STG_E_REVERTED;
 
  /*
   * Check that we're compatible with the parent's storage mode,
   * but only if we are not transacted
   */
  if(!(This->openFlags & STGM_TRANSACTED)) {
    if ( STGM_ACCESS_MODE( grfMode ) > STGM_ACCESS_MODE( This->openFlags ) )
    {
      res = STG_E_ACCESSDENIED;
      goto end;
    }
  }
 
  *ppstg = NULL;
 
  storageEntryRef = findElement(
                         This,
                         This->storageDirEntry,
                         pwcsName,
                         &currentEntry);
 
  if ( (storageEntryRef!=DIRENTRY_NULL) &&
       (currentEntry.stgType==STGTY_STORAGE) )
  {
    if (StorageBaseImpl_IsStorageOpen(This, storageEntryRef))
    {
      /* A single storage cannot be opened a second time. */
      res = STG_E_ACCESSDENIED;
      goto end;
    }
 
    newStorage = StorageInternalImpl_Construct(
                   This,
                   grfMode,
                   storageEntryRef);
 
    if (newStorage != 0)
    {
      if (grfMode & STGM_TRANSACTED)
      {
        res = Storage_ConstructTransacted(&newStorage->base, FALSE, &newTransactedStorage);
 
        if (FAILED(res))
        {
          HeapFree(GetProcessHeap(), 0, newStorage);
          goto end;
        }
 
        *ppstg = &newTransactedStorage->IStorage_iface;
      }
      else
      {
        *ppstg = &newStorage->base.IStorage_iface;
      }
 
      list_add_tail(&This->storageHead, &newStorage->ParentListEntry);
 
      res = S_OK;
      goto end;
    }
 
    res = STG_E_INSUFFICIENTMEMORY;
    goto end;
  }
 
  res = STG_E_FILENOTFOUND;
 
end:
  TRACE("<-- %08x\n", res);
  return res;
}

StorageBaseImpl_OpenStream()

static HRESULT WINAPI StorageBaseImpl_OpenStream ( IStorage *  iface, const OLECHAR *  pwcsName, void *  reserved1, DWORD  grfMode, DWORD  reserved2, IStream **  ppstm  )

static

Definition at line 1495 of file storage32.c.

{
  StorageBaseImpl *This = impl_from_IStorage(iface);
  StgStreamImpl*    newStream;
  DirEntry          currentEntry;
  DirRef            streamEntryRef;
  HRESULT           res = STG_E_UNKNOWN;
 
  TRACE("(%p, %s, %p, %x, %d, %p)\n",
    iface, debugstr_w(pwcsName), reserved1, grfMode, reserved2, ppstm);
 
  if ( (pwcsName==NULL) || (ppstm==0) )
  {
    res = E_INVALIDARG;
    goto end;
  }
 
  *ppstm = NULL;
 
  if ( FAILED( validateSTGM(grfMode) ) ||
       STGM_SHARE_MODE(grfMode) != STGM_SHARE_EXCLUSIVE)
  {
    res = STG_E_INVALIDFLAG;
    goto end;
  }
 
  /*
   * As documented.
   */
  if ( (grfMode & STGM_DELETEONRELEASE) || (grfMode & STGM_TRANSACTED) )
  {
    res = STG_E_INVALIDFUNCTION;
    goto end;
  }
 
  if (This->reverted)
  {
    res = STG_E_REVERTED;
    goto end;
  }
 
  /*
   * Check that we're compatible with the parent's storage mode, but
   * only if we are not in transacted mode
   */
  if(!(This->openFlags & STGM_TRANSACTED)) {
    if ( STGM_ACCESS_MODE( grfMode ) > STGM_ACCESS_MODE( This->openFlags ) )
    {
      res = STG_E_INVALIDFLAG;
      goto end;
    }
  }
 
  /*
   * Search for the element with the given name
   */
  streamEntryRef = findElement(
    This,
    This->storageDirEntry,
    pwcsName,
    &currentEntry);
 
  /*
   * If it was found, construct the stream object and return a pointer to it.
   */
  if ( (streamEntryRef!=DIRENTRY_NULL) &&
       (currentEntry.stgType==STGTY_STREAM) )
  {
    if (StorageBaseImpl_IsStreamOpen(This, streamEntryRef))
    {
      /* A single stream cannot be opened a second time. */
      res = STG_E_ACCESSDENIED;
      goto end;
    }
 
    newStream = StgStreamImpl_Construct(This, grfMode, streamEntryRef);
 
    if (newStream)
    {
      newStream->grfMode = grfMode;
      *ppstm = &newStream->IStream_iface;
 
      IStream_AddRef(*ppstm);
 
      res = S_OK;
      goto end;
    }
 
    res = E_OUTOFMEMORY;
    goto end;
  }
 
  res = STG_E_FILENOTFOUND;
 
end:
  if (res == S_OK)
    TRACE("<-- IStream %p\n", *ppstm);
  TRACE("<-- %08x\n", res);
  return res;
}

StorageBaseImpl_QueryInterface()

static HRESULT WINAPI StorageBaseImpl_QueryInterface ( IStorage *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 1232 of file storage32.c.

{
  StorageBaseImpl *This = impl_from_IStorage(iface);
 
  TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), ppvObject);
 
  if (!ppvObject)
    return E_INVALIDARG;
 
  *ppvObject = 0;
 
  if (IsEqualGUID(&IID_IUnknown, riid) ||
      IsEqualGUID(&IID_IStorage, riid))
  {
    *ppvObject = &This->IStorage_iface;
  }
  else if (IsEqualGUID(&IID_IPropertySetStorage, riid))
  {
    *ppvObject = &This->IPropertySetStorage_iface;
  }
  /* locking interface is reported for writer only */
  else if (IsEqualGUID(&IID_IDirectWriterLock, riid) && This->lockingrole == SWMR_Writer)
  {
    *ppvObject = &This->IDirectWriterLock_iface;
  }
  else
  {
    TRACE("<-- E_NOINTERFACE\n");
    return E_NOINTERFACE;
  }
 
  IStorage_AddRef(iface);
  TRACE("<-- %p\n", *ppvObject);
  return S_OK;
}

StorageBaseImpl_Release()

static ULONG WINAPI StorageBaseImpl_Release ( IStorage *  iface )

static

Definition at line 1298 of file storage32.c.

{
  StorageBaseImpl *This = impl_from_IStorage(iface);
 
  ULONG ref = InterlockedDecrement(&This->ref);
 
  TRACE("(%p) ReleaseRef to %d\n", This, ref);
 
  if (ref == 0)
  {
    /*
     * Since we are using a system of base-classes, we want to call the
     * destructor of the appropriate derived class. To do this, we are
     * using virtual functions to implement the destructor.
     */
    StorageBaseImpl_Destroy(This);
  }
 
  return ref;
}

StorageBaseImpl_RemoveStream()

void StorageBaseImpl_RemoveStream	(	StorageBaseImpl *	stg,
		StgStreamImpl *	strm
	)

Definition at line 2720 of file storage32.c.

{
  TRACE("Stream removed (stg=%p strm=%p)\n", stg,strm);
  list_remove(&(strm->StrmListEntry));
}

Referenced by StgStreamImpl_Release().

StorageBaseImpl_RenameElement()

static HRESULT WINAPI StorageBaseImpl_RenameElement ( IStorage *  iface, const OLECHAR *  pwcsOldName, const OLECHAR *  pwcsNewName  )

static

Definition at line 1843 of file storage32.c.

{
  StorageBaseImpl *This = impl_from_IStorage(iface);
  DirEntry          currentEntry;
  DirRef            currentEntryRef;
 
  TRACE("(%p, %s, %s)\n",
    iface, debugstr_w(pwcsOldName), debugstr_w(pwcsNewName));
 
  if (This->reverted)
    return STG_E_REVERTED;
 
  currentEntryRef = findElement(This,
                                   This->storageDirEntry,
                                   pwcsNewName,
                                   &currentEntry);
 
  if (currentEntryRef != DIRENTRY_NULL)
  {
    /*
     * There is already an element with the new name
     */
    return STG_E_FILEALREADYEXISTS;
  }
 
  /*
   * Search for the old element name
   */
  currentEntryRef = findElement(This,
                                   This->storageDirEntry,
                                   pwcsOldName,
                                   &currentEntry);
 
  if (currentEntryRef != DIRENTRY_NULL)
  {
    if (StorageBaseImpl_IsStreamOpen(This, currentEntryRef) ||
        StorageBaseImpl_IsStorageOpen(This, currentEntryRef))
    {
      WARN("Element is already open; cannot rename.\n");
      return STG_E_ACCESSDENIED;
    }
 
    /* Remove the element from its current position in the tree */
    removeFromTree(This, This->storageDirEntry,
        currentEntryRef);
 
    /* Change the name of the element */
    lstrcpyW(currentEntry.name, pwcsNewName);
 
    /* Delete any sibling links */
    currentEntry.leftChild = DIRENTRY_NULL;
    currentEntry.rightChild = DIRENTRY_NULL;
 
    StorageBaseImpl_WriteDirEntry(This, currentEntryRef,
        &currentEntry);
 
    /* Insert the element in a new position in the tree */
    insertIntoTree(This, This->storageDirEntry,
        currentEntryRef);
  }
  else
  {
    /*
     * There is no element with the old name
     */
    return STG_E_FILENOTFOUND;
  }
 
  return StorageBaseImpl_Flush(This);
}

StorageBaseImpl_Revert()

static HRESULT WINAPI StorageBaseImpl_Revert ( IStorage *  iface )

static

Definition at line 2412 of file storage32.c.

{
  TRACE("(%p)\n", iface);
  return S_OK;
}

StorageBaseImpl_SetClass()

static HRESULT WINAPI StorageBaseImpl_SetClass ( IStorage *  iface, REFCLSID  clsid  )

static

Definition at line 2079 of file storage32.c.

{
  StorageBaseImpl *This = impl_from_IStorage(iface);
  HRESULT hRes;
  DirEntry currentEntry;
 
  TRACE("(%p, %s)\n", iface, wine_dbgstr_guid(clsid));
 
  if (This->reverted)
    return STG_E_REVERTED;
 
  hRes = StorageBaseImpl_ReadDirEntry(This,
                                      This->storageDirEntry,
                                      &currentEntry);
  if (SUCCEEDED(hRes))
  {
    currentEntry.clsid = *clsid;
 
    hRes = StorageBaseImpl_WriteDirEntry(This,
                                         This->storageDirEntry,
                                         &currentEntry);
  }
 
  if (SUCCEEDED(hRes))
    hRes = StorageBaseImpl_Flush(This);
 
  return hRes;
}

StorageBaseImpl_SetElementTimes()

static HRESULT WINAPI StorageBaseImpl_SetElementTimes ( IStorage *  iface, const OLECHAR *  pwcsName, const FILETIME *  pctime, const FILETIME *  patime, const FILETIME *  pmtime  )

static

Definition at line 2682 of file storage32.c.

{
  FIXME("(%s,...), stub!\n",debugstr_w(pwcsName));
  return S_OK;
}

StorageBaseImpl_SetStateBits()

static HRESULT WINAPI StorageBaseImpl_SetStateBits ( IStorage *  iface, DWORD  grfStateBits, DWORD  grfMask  )

static

Definition at line 2696 of file storage32.c.

{
  StorageBaseImpl *This = impl_from_IStorage(iface);
 
  if (This->reverted)
    return STG_E_REVERTED;
 
  This->stateBits = (This->stateBits & ~grfMask) | (grfStateBits & grfMask);
  return S_OK;
}

StorageBaseImpl_Stat()

static HRESULT WINAPI StorageBaseImpl_Stat ( IStorage *  iface, STATSTG *  pstatstg, DWORD  grfStatFlag  )

static

Definition at line 1786 of file storage32.c.

{
  StorageBaseImpl *This = impl_from_IStorage(iface);
  DirEntry       currentEntry;
  HRESULT        res = STG_E_UNKNOWN;
 
  TRACE("(%p, %p, %x)\n",
    iface, pstatstg, grfStatFlag);
 
  if (!pstatstg)
  {
    res = E_INVALIDARG;
    goto end;
  }
 
  if (This->reverted)
  {
    res = STG_E_REVERTED;
    goto end;
  }
 
  res = StorageBaseImpl_ReadDirEntry(
                    This,
                    This->storageDirEntry,
                    &currentEntry);
 
  if (SUCCEEDED(res))
  {
    StorageUtl_CopyDirEntryToSTATSTG(
      This,
      pstatstg,
      &currentEntry,
      grfStatFlag);
 
    pstatstg->grfMode = This->openFlags;
    pstatstg->grfStateBits = This->stateBits;
  }
 
end:
  if (res == S_OK)
  {
    TRACE("<-- STATSTG: pwcsName: %s, type: %d, cbSize.Low/High: %d/%d, grfMode: %08x, grfLocksSupported: %d, grfStateBits: %08x\n", debugstr_w(pstatstg->pwcsName), pstatstg->type, pstatstg->cbSize.u.LowPart, pstatstg->cbSize.u.HighPart, pstatstg->grfMode, pstatstg->grfLocksSupported, pstatstg->grfStateBits);
  }
  TRACE("<-- %08x\n", res);
  return res;
}

StorageImpl_BaseReadDirEntry()

static HRESULT StorageImpl_BaseReadDirEntry ( StorageBaseImpl *  base, DirRef  index, DirEntry *  data  )

static

Definition at line 4332 of file storage32.c.

{
  StorageImpl *This = (StorageImpl*)base;
  return StorageImpl_ReadDirEntry(This, index, data);
}

StorageImpl_BaseWriteDirEntry()

static HRESULT StorageImpl_BaseWriteDirEntry ( StorageBaseImpl *  base, DirRef  index, const DirEntry *  data  )

static

Definition at line 4325 of file storage32.c.

{
  StorageImpl *This = (StorageImpl*)base;
  return StorageImpl_WriteDirEntry(This, index, data);
}

StorageImpl_CheckLockRange()

static HRESULT StorageImpl_CheckLockRange ( StorageImpl *  This, ULONG  start, ULONG  end, HRESULT  fail_hr  )

static

Definition at line 5023 of file storage32.c.

{
    HRESULT hr;
    ULARGE_INTEGER offset, cb;
 
    offset.QuadPart = start;
    cb.QuadPart = 1 + end - start;
 
    hr = StorageImpl_LockRegion(This, offset, cb, LOCK_ONLYONCE, NULL);
    if (SUCCEEDED(hr)) StorageImpl_UnlockRegion(This, offset, cb, LOCK_ONLYONCE);
 
    if (FAILED(hr))
        return fail_hr;
    else
        return S_OK;
}

Referenced by StorageImpl_GrabLocks().

StorageImpl_Construct()

static HRESULT StorageImpl_Construct ( HANDLE  hFile, LPCOLESTR  pwcsName, ILockBytes *  pLkbyt, DWORD  openFlags, BOOL  fileBased, BOOL  create, ULONG  sector_size, StorageImpl **  result  )

static

Definition at line 5268 of file storage32.c.

{
  StorageImpl* This;
  HRESULT hr = S_OK;
  STATSTG stat;
 
  if ( FAILED( validateSTGM(openFlags) ))
    return STG_E_INVALIDFLAG;
 
  This = HeapAlloc(GetProcessHeap(), 0, sizeof(StorageImpl));
  if (!This)
    return E_OUTOFMEMORY;
 
  memset(This, 0, sizeof(StorageImpl));
 
  list_init(&This->base.strmHead);
 
  list_init(&This->base.storageHead);
 
  This->base.IStorage_iface.lpVtbl = &StorageImpl_Vtbl;
  This->base.IPropertySetStorage_iface.lpVtbl = &IPropertySetStorage_Vtbl;
  This->base.IDirectWriterLock_iface.lpVtbl = &DirectWriterLockVtbl;
  This->base.baseVtbl = &StorageImpl_BaseVtbl;
  This->base.openFlags = (openFlags & ~STGM_CREATE);
  This->base.ref = 1;
  This->base.create = create;
 
  if (openFlags == (STGM_DIRECT_SWMR|STGM_READWRITE|STGM_SHARE_DENY_WRITE))
    This->base.lockingrole = SWMR_Writer;
  else if (openFlags == (STGM_DIRECT_SWMR|STGM_READ|STGM_SHARE_DENY_NONE))
    This->base.lockingrole = SWMR_Reader;
  else
    This->base.lockingrole = SWMR_None;
 
  This->base.reverted = FALSE;
 
  /*
   * Initialize the big block cache.
   */
  This->bigBlockSize   = sector_size;
  This->smallBlockSize = DEF_SMALL_BLOCK_SIZE;
  if (hFile)
    hr = FileLockBytesImpl_Construct(hFile, openFlags, pwcsName, &This->lockBytes);
  else
  {
    This->lockBytes = pLkbyt;
    ILockBytes_AddRef(pLkbyt);
  }
 
  if (SUCCEEDED(hr))
    hr = ILockBytes_Stat(This->lockBytes, &stat, STATFLAG_NONAME);
 
  if (SUCCEEDED(hr))
  {
    This->locks_supported = stat.grfLocksSupported;
    if (!hFile)
        /* Don't try to use wine-internal locking flag with custom ILockBytes */
        This->locks_supported &= ~WINE_LOCK_READ;
 
    hr = StorageImpl_GrabLocks(This, openFlags);
  }
 
  if (SUCCEEDED(hr))
    hr = StorageImpl_Refresh(This, TRUE, create);
 
  if (FAILED(hr))
  {
    IStorage_Release(&This->base.IStorage_iface);
    *result = NULL;
  }
  else
  {
    StorageImpl_Flush(&This->base);
    *result = This;
  }
 
  return hr;
}

Referenced by Storage_Construct().

StorageImpl_CreateDirEntry()

static HRESULT StorageImpl_CreateDirEntry ( StorageBaseImpl *  base, const DirEntry *  newData, DirRef *  index  )

static

Definition at line 3317 of file storage32.c.

{
  StorageImpl *storage = (StorageImpl*)base;
  ULONG       currentEntryIndex    = 0;
  ULONG       newEntryIndex        = DIRENTRY_NULL;
  HRESULT hr = S_OK;
  BYTE currentData[RAW_DIRENTRY_SIZE];
  WORD sizeOfNameString;
 
  do
  {
    hr = StorageImpl_ReadRawDirEntry(storage,
                                     currentEntryIndex,
                                     currentData);
 
    if (SUCCEEDED(hr))
    {
      StorageUtl_ReadWord(
        currentData,
        OFFSET_PS_NAMELENGTH,
        &sizeOfNameString);
 
      if (sizeOfNameString == 0)
      {
        /*
         * The entry exists and is available, we found it.
         */
        newEntryIndex = currentEntryIndex;
      }
    }
    else
    {
      /*
       * We exhausted the directory entries, we will create more space below
       */
      newEntryIndex = currentEntryIndex;
    }
    currentEntryIndex++;
 
  } while (newEntryIndex == DIRENTRY_NULL);
 
  /*
   * grow the directory stream
   */
  if (FAILED(hr))
  {
    BYTE           emptyData[RAW_DIRENTRY_SIZE];
    ULARGE_INTEGER newSize;
    ULONG          entryIndex;
    ULONG          lastEntry     = 0;
    ULONG          blockCount    = 0;
 
    /*
     * obtain the new count of blocks in the directory stream
     */
    blockCount = BlockChainStream_GetCount(
                   storage->rootBlockChain)+1;
 
    /*
     * initialize the size used by the directory stream
     */
    newSize.QuadPart  = (ULONGLONG)storage->bigBlockSize * blockCount;
 
    /*
     * add a block to the directory stream
     */
    BlockChainStream_SetSize(storage->rootBlockChain, newSize);
 
    /*
     * memset the empty entry in order to initialize the unused newly
     * created entries
     */
    memset(emptyData, 0, RAW_DIRENTRY_SIZE);
 
    /*
     * initialize them
     */
    lastEntry = storage->bigBlockSize / RAW_DIRENTRY_SIZE * blockCount;
 
    for(
      entryIndex = newEntryIndex + 1;
      entryIndex < lastEntry;
      entryIndex++)
    {
      StorageImpl_WriteRawDirEntry(
        storage,
        entryIndex,
        emptyData);
    }
 
    StorageImpl_SaveFileHeader(storage);
  }
 
  UpdateRawDirEntry(currentData, newData);
 
  hr = StorageImpl_WriteRawDirEntry(storage, newEntryIndex, currentData);
 
  if (SUCCEEDED(hr))
    *index = newEntryIndex;
 
  return hr;
}

StorageImpl_DeleteCachedBlockChainStream()

static void StorageImpl_DeleteCachedBlockChainStream ( StorageImpl *  This, DirRef  index  )

static

Definition at line 4396 of file storage32.c.

{
  int i;
 
  for (i=0; i<BLOCKCHAIN_CACHE_SIZE; i++)
  {
    if (This->blockChainCache[i] && This->blockChainCache[i]->ownerDirEntry == index)
    {
      BlockChainStream_Destroy(This->blockChainCache[i]);
      This->blockChainCache[i] = NULL;
      return;
    }
  }
}

Referenced by StorageImpl_StreamLink().

StorageImpl_Destroy()

static void StorageImpl_Destroy ( StorageBaseImpl *  iface )

static

Definition at line 5186 of file storage32.c.

{
  StorageImpl *This = (StorageImpl*) iface;
  int i;
  TRACE("(%p)\n", This);
 
  StorageImpl_Flush(iface);
 
  StorageImpl_Invalidate(iface);
 
  HeapFree(GetProcessHeap(), 0, This->extBigBlockDepotLocations);
 
  BlockChainStream_Destroy(This->smallBlockRootChain);
  BlockChainStream_Destroy(This->rootBlockChain);
  BlockChainStream_Destroy(This->smallBlockDepotChain);
 
  for (i = 0; i < BLOCKCHAIN_CACHE_SIZE; i++)
    BlockChainStream_Destroy(This->blockChainCache[i]);
 
  for (i = 0; i < ARRAY_SIZE(This->locked_bytes); i++)
  {
    ULARGE_INTEGER offset, cb;
    cb.QuadPart = 1;
    if (This->locked_bytes[i] != 0)
    {
      offset.QuadPart = This->locked_bytes[i];
      StorageImpl_UnlockRegion(This, offset, cb, LOCK_ONLYONCE);
    }
  }
 
  if (This->lockBytes)
    ILockBytes_Release(This->lockBytes);
  HeapFree(GetProcessHeap(), 0, This);
}

StorageImpl_DestroyDirEntry()

static HRESULT StorageImpl_DestroyDirEntry ( StorageBaseImpl *  base, DirRef  index  )

static

Definition at line 3220 of file storage32.c.

{
  BYTE emptyData[RAW_DIRENTRY_SIZE];
  StorageImpl *storage = (StorageImpl*)base;
 
  memset(emptyData, 0, RAW_DIRENTRY_SIZE);
 
  return StorageImpl_WriteRawDirEntry(storage, index, emptyData);
}

StorageImpl_Flush()

static HRESULT StorageImpl_Flush ( StorageBaseImpl *  storage )

static

Definition at line 5152 of file storage32.c.

{
  StorageImpl *This = (StorageImpl*)storage;
  int i;
  HRESULT hr;
  TRACE("(%p)\n", This);
 
  hr = BlockChainStream_Flush(This->smallBlockRootChain);
 
  if (SUCCEEDED(hr))
    hr = BlockChainStream_Flush(This->rootBlockChain);
 
  if (SUCCEEDED(hr))
    hr = BlockChainStream_Flush(This->smallBlockDepotChain);
 
  for (i=0; SUCCEEDED(hr) && i<BLOCKCHAIN_CACHE_SIZE; i++)
    if (This->blockChainCache[i])
      hr = BlockChainStream_Flush(This->blockChainCache[i]);
 
  if (SUCCEEDED(hr))
    hr = ILockBytes_Flush(This->lockBytes);
 
  return hr;
}

Referenced by StorageImpl_Construct(), and StorageImpl_Destroy().

StorageImpl_FreeBigBlock()

static void StorageImpl_FreeBigBlock ( StorageImpl *  This, ULONG  blockIndex  )

static

Definition at line 4314 of file storage32.c.

{
  StorageImpl_SetNextBlockInChain(This, blockIndex, BLOCK_UNUSED);
 
  if (blockIndex < This->prevFreeBlock)
    This->prevFreeBlock = blockIndex;
}

Referenced by BlockChainStream_Shrink().

StorageImpl_GetBigBlockOffset()

static ULONGLONG StorageImpl_GetBigBlockOffset ( StorageImpl *  This, ULONG  index  )

static

Definition at line 3541 of file storage32.c.

{
    return (ULONGLONG)(index+1) * This->bigBlockSize;
}

Referenced by BlockChainStream_ReadAt(), BlockChainStream_WriteAt(), StorageImpl_GetNextFreeBigBlock(), StorageImpl_ReadBigBlock(), StorageImpl_ReadDWordFromBigBlock(), StorageImpl_WriteBigBlock(), and StorageImpl_WriteDWordToBigBlock().

StorageImpl_GetCachedBlockChainStream()

static BlockChainStream ** StorageImpl_GetCachedBlockChainStream ( StorageImpl *  This, DirRef  index  )

static

Definition at line 4363 of file storage32.c.

{
  int i, free_index=-1;
 
  for (i=0; i<BLOCKCHAIN_CACHE_SIZE; i++)
  {
    if (!This->blockChainCache[i])
    {
      if (free_index == -1) free_index = i;
    }
    else if (This->blockChainCache[i]->ownerDirEntry == index)
    {
      return &This->blockChainCache[i];
    }
  }
 
  if (free_index == -1)
  {
    free_index = This->blockChainToEvict;
 
    BlockChainStream_Destroy(This->blockChainCache[free_index]);
    This->blockChainCache[free_index] = NULL;
 
    This->blockChainToEvict++;
    if (This->blockChainToEvict == BLOCKCHAIN_CACHE_SIZE)
      This->blockChainToEvict = 0;
  }
 
  This->blockChainCache[free_index] = BlockChainStream_Construct(This, NULL, index);
  return &This->blockChainCache[free_index];
}

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

StorageImpl_GetFilename()

static HRESULT StorageImpl_GetFilename ( StorageBaseImpl *  iface, LPWSTR *  result  )

static

Definition at line 5010 of file storage32.c.

{
  StorageImpl *This = (StorageImpl*) iface;
  STATSTG statstg;
  HRESULT hr;
 
  hr = ILockBytes_Stat(This->lockBytes, &statstg, 0);
 
  *result = statstg.pwcsName;
 
  return hr;
}

StorageImpl_GetFreeBlockChainCacheEntry()

static BlockChainStream ** StorageImpl_GetFreeBlockChainCacheEntry ( StorageImpl *  This )

static

Definition at line 4339 of file storage32.c.

{
  int i;
 
  for (i=0; i<BLOCKCHAIN_CACHE_SIZE; i++)
  {
    if (!This->blockChainCache[i])
    {
      return &This->blockChainCache[i];
    }
  }
 
  i = This->blockChainToEvict;
 
  BlockChainStream_Destroy(This->blockChainCache[i]);
  This->blockChainCache[i] = NULL;
 
  This->blockChainToEvict++;
  if (This->blockChainToEvict == BLOCKCHAIN_CACHE_SIZE)
    This->blockChainToEvict = 0;
 
  return &This->blockChainCache[i];
}

Referenced by StorageImpl_StreamSetSize().

StorageImpl_GetNextBlockInChain()

static HRESULT StorageImpl_GetNextBlockInChain ( StorageImpl *  This, ULONG  blockIndex, ULONG *  nextBlockIndex  )

static

Definition at line 4021 of file storage32.c.

{
  ULONG offsetInDepot    = blockIndex * sizeof (ULONG);
  ULONG depotBlockCount  = offsetInDepot / This->bigBlockSize;
  ULONG depotBlockOffset = offsetInDepot % This->bigBlockSize;
  BYTE depotBuffer[MAX_BIG_BLOCK_SIZE];
  ULONG read;
  ULONG depotBlockIndexPos;
  int index, num_blocks;
 
  *nextBlockIndex   = BLOCK_SPECIAL;
 
  if(depotBlockCount >= This->bigBlockDepotCount)
  {
    WARN("depotBlockCount %d, bigBlockDepotCount %d\n", depotBlockCount,
     This->bigBlockDepotCount);
    return STG_E_READFAULT;
  }
 
  /*
   * Cache the currently accessed depot block.
   */
  if (depotBlockCount != This->indexBlockDepotCached)
  {
    This->indexBlockDepotCached = depotBlockCount;
 
    if (depotBlockCount < COUNT_BBDEPOTINHEADER)
    {
      depotBlockIndexPos = This->bigBlockDepotStart[depotBlockCount];
    }
    else
    {
      /*
       * We have to look in the extended depot.
       */
      depotBlockIndexPos = Storage32Impl_GetExtDepotBlock(This, depotBlockCount);
    }
 
    StorageImpl_ReadBigBlock(This, depotBlockIndexPos, depotBuffer, &read);
 
    if (!read)
      return STG_E_READFAULT;
 
    num_blocks = This->bigBlockSize / 4;
 
    for (index = 0; index < num_blocks; index++)
    {
      StorageUtl_ReadDWord(depotBuffer, index*sizeof(ULONG), nextBlockIndex);
      This->blockDepotCached[index] = *nextBlockIndex;
    }
  }
 
  *nextBlockIndex = This->blockDepotCached[depotBlockOffset/sizeof(ULONG)];
 
  return S_OK;
}

Referenced by BlockChainStream_Enlarge(), and BlockChainStream_UpdateIndexCache().

StorageImpl_GetNextFreeBigBlock()

static ULONG StorageImpl_GetNextFreeBigBlock ( StorageImpl *  This )

static

Definition at line 4171 of file storage32.c.

{
  ULONG depotBlockIndexPos;
  BYTE depotBuffer[MAX_BIG_BLOCK_SIZE];
  ULONG depotBlockOffset;
  ULONG blocksPerDepot    = This->bigBlockSize / sizeof(ULONG);
  ULONG nextBlockIndex    = BLOCK_SPECIAL;
  int   depotIndex        = 0;
  ULONG freeBlock         = BLOCK_UNUSED;
  ULONG read;
  ULARGE_INTEGER neededSize;
  STATSTG statstg;
 
  depotIndex = This->prevFreeBlock / blocksPerDepot;
  depotBlockOffset = (This->prevFreeBlock % blocksPerDepot) * sizeof(ULONG);
 
  /*
   * Scan the entire big block depot until we find a block marked free
   */
  while (nextBlockIndex != BLOCK_UNUSED)
  {
    if (depotIndex < COUNT_BBDEPOTINHEADER)
    {
      depotBlockIndexPos = This->bigBlockDepotStart[depotIndex];
 
      /*
       * Grow the primary depot.
       */
      if (depotBlockIndexPos == BLOCK_UNUSED)
      {
        depotBlockIndexPos = depotIndex*blocksPerDepot;
 
        /*
         * Add a block depot.
         */
        Storage32Impl_AddBlockDepot(This, depotBlockIndexPos, depotIndex);
        This->bigBlockDepotCount++;
        This->bigBlockDepotStart[depotIndex] = depotBlockIndexPos;
 
        /*
         * Flag it as a block depot.
         */
        StorageImpl_SetNextBlockInChain(This,
                                          depotBlockIndexPos,
                                          BLOCK_SPECIAL);
 
        /* Save new header information.
         */
        StorageImpl_SaveFileHeader(This);
      }
    }
    else
    {
      depotBlockIndexPos = Storage32Impl_GetExtDepotBlock(This, depotIndex);
 
      if (depotBlockIndexPos == BLOCK_UNUSED)
      {
        /*
         * Grow the extended depot.
         */
        ULONG extIndex       = BLOCK_UNUSED;
        ULONG numExtBlocks   = depotIndex - COUNT_BBDEPOTINHEADER;
        ULONG extBlockOffset = numExtBlocks % (blocksPerDepot - 1);
 
        if (extBlockOffset == 0)
        {
          /* We need an extended block.
           */
          extIndex = Storage32Impl_AddExtBlockDepot(This);
          This->extBigBlockDepotCount++;
          depotBlockIndexPos = extIndex + 1;
        }
        else
          depotBlockIndexPos = depotIndex * blocksPerDepot;
 
        /*
         * Add a block depot and mark it in the extended block.
         */
        Storage32Impl_AddBlockDepot(This, depotBlockIndexPos, depotIndex);
        This->bigBlockDepotCount++;
        Storage32Impl_SetExtDepotBlock(This, depotIndex, depotBlockIndexPos);
 
        /* Flag the block depot.
         */
        StorageImpl_SetNextBlockInChain(This,
                                          depotBlockIndexPos,
                                          BLOCK_SPECIAL);
 
        /* If necessary, flag the extended depot block.
         */
        if (extIndex != BLOCK_UNUSED)
          StorageImpl_SetNextBlockInChain(This, extIndex, BLOCK_EXTBBDEPOT);
 
        /* Save header information.
         */
        StorageImpl_SaveFileHeader(This);
      }
    }
 
    StorageImpl_ReadBigBlock(This, depotBlockIndexPos, depotBuffer, &read);
 
    if (read)
    {
      while ( ( (depotBlockOffset/sizeof(ULONG) ) < blocksPerDepot) &&
              ( nextBlockIndex != BLOCK_UNUSED))
      {
        StorageUtl_ReadDWord(depotBuffer, depotBlockOffset, &nextBlockIndex);
 
        if (nextBlockIndex == BLOCK_UNUSED)
        {
          freeBlock = (depotIndex * blocksPerDepot) +
                      (depotBlockOffset/sizeof(ULONG));
        }
 
        depotBlockOffset += sizeof(ULONG);
      }
    }
 
    depotIndex++;
    depotBlockOffset = 0;
  }
 
  /*
   * make sure that the block physically exists before using it
   */
  neededSize.QuadPart = StorageImpl_GetBigBlockOffset(This, freeBlock)+This->bigBlockSize;
 
  ILockBytes_Stat(This->lockBytes, &statstg, STATFLAG_NONAME);
 
  if (neededSize.QuadPart > statstg.cbSize.QuadPart)
    ILockBytes_SetSize(This->lockBytes, neededSize);
 
  This->prevFreeBlock = freeBlock;
 
  return freeBlock;
}

Referenced by BlockChainStream_Enlarge().

StorageImpl_GetTransactionSig()

static HRESULT StorageImpl_GetTransactionSig ( StorageBaseImpl *  base, ULONG *  result, BOOL  refresh  )

static

Definition at line 4838 of file storage32.c.

{
  StorageImpl *This = (StorageImpl*)base;
  HRESULT hr=S_OK;
  DWORD oldTransactionSig = This->transactionSig;
 
  if (refresh)
  {
    ULARGE_INTEGER offset;
    ULONG bytes_read;
    BYTE data[4];
 
    offset.u.HighPart = 0;
    offset.u.LowPart = OFFSET_TRANSACTIONSIG;
    hr = StorageImpl_ReadAt(This, offset, data, 4, &bytes_read);
 
    if (SUCCEEDED(hr))
    {
      StorageUtl_ReadDWord(data, 0, &This->transactionSig);
 
      if (oldTransactionSig != This->transactionSig)
      {
        /* Someone else wrote to this, so toss all cached information. */
        TRACE("signature changed\n");
 
        hr = StorageImpl_Refresh(This, FALSE, FALSE);
      }
 
      if (FAILED(hr))
        This->transactionSig = oldTransactionSig;
    }
  }
 
  *result = This->transactionSig;
 
  return hr;
}

StorageImpl_GrabLocks()

static HRESULT StorageImpl_GrabLocks ( StorageImpl *  This, DWORD  openFlags  )

static

Definition at line 5072 of file storage32.c.

{
    HRESULT hr;
    ULARGE_INTEGER offset;
    ULARGE_INTEGER cb;
    DWORD share_mode = STGM_SHARE_MODE(openFlags);
    BOOL supported;
 
    if (openFlags & STGM_NOSNAPSHOT)
    {
        /* STGM_NOSNAPSHOT implies deny write */
        if (share_mode == STGM_SHARE_DENY_READ) share_mode = STGM_SHARE_EXCLUSIVE;
        else if (share_mode != STGM_SHARE_EXCLUSIVE) share_mode = STGM_SHARE_DENY_WRITE;
    }
 
    /* Wrap all other locking inside a single lock so we can check ranges safely */
    offset.QuadPart = RANGELOCK_CHECKLOCKS;
    cb.QuadPart = 1;
    hr = StorageImpl_LockRegionSync(This, offset, cb, LOCK_ONLYONCE, &supported);
 
    /* If the ILockBytes doesn't support locking that's ok. */
    if (!supported) return S_OK;
    else if (FAILED(hr)) return hr;
 
    hr = S_OK;
 
    /* First check for any conflicting locks. */
    if ((openFlags & STGM_PRIORITY) == STGM_PRIORITY)
        hr = StorageImpl_CheckLockRange(This, RANGELOCK_COMMIT, RANGELOCK_COMMIT, STG_E_LOCKVIOLATION);
 
    if (SUCCEEDED(hr) && (STGM_ACCESS_MODE(openFlags) != STGM_WRITE))
        hr = StorageImpl_CheckLockRange(This, RANGELOCK_DENY_READ_FIRST, RANGELOCK_DENY_READ_LAST, STG_E_SHAREVIOLATION);
 
    if (SUCCEEDED(hr) && (STGM_ACCESS_MODE(openFlags) != STGM_READ))
        hr = StorageImpl_CheckLockRange(This, RANGELOCK_DENY_WRITE_FIRST, RANGELOCK_DENY_WRITE_LAST, STG_E_SHAREVIOLATION);
 
    if (SUCCEEDED(hr) && (share_mode == STGM_SHARE_DENY_READ || share_mode == STGM_SHARE_EXCLUSIVE))
        hr = StorageImpl_CheckLockRange(This, RANGELOCK_READ_FIRST, RANGELOCK_READ_LAST, STG_E_LOCKVIOLATION);
 
    if (SUCCEEDED(hr) && (share_mode == STGM_SHARE_DENY_WRITE || share_mode == STGM_SHARE_EXCLUSIVE))
        hr = StorageImpl_CheckLockRange(This, RANGELOCK_WRITE_FIRST, RANGELOCK_WRITE_LAST, STG_E_LOCKVIOLATION);
 
    if (SUCCEEDED(hr) && STGM_ACCESS_MODE(openFlags) == STGM_READ && share_mode == STGM_SHARE_EXCLUSIVE)
    {
        hr = StorageImpl_CheckLockRange(This, 0, RANGELOCK_CHECKLOCKS-1, STG_E_LOCKVIOLATION);
 
        if (SUCCEEDED(hr))
            hr = StorageImpl_CheckLockRange(This, RANGELOCK_CHECKLOCKS+1, RANGELOCK_LAST, STG_E_LOCKVIOLATION);
    }
 
    /* Then grab our locks. */
    if (SUCCEEDED(hr) && (openFlags & STGM_PRIORITY) == STGM_PRIORITY)
    {
        hr = StorageImpl_LockOne(This, RANGELOCK_PRIORITY1_FIRST, RANGELOCK_PRIORITY1_LAST);
        if (SUCCEEDED(hr))
            hr = StorageImpl_LockOne(This, RANGELOCK_PRIORITY2_FIRST, RANGELOCK_PRIORITY2_LAST);
    }
 
    if (SUCCEEDED(hr) && (STGM_ACCESS_MODE(openFlags) != STGM_WRITE))
        hr = StorageImpl_LockOne(This, RANGELOCK_READ_FIRST, RANGELOCK_READ_LAST);
 
    if (SUCCEEDED(hr) && (STGM_ACCESS_MODE(openFlags) != STGM_READ))
        hr = StorageImpl_LockOne(This, RANGELOCK_WRITE_FIRST, RANGELOCK_WRITE_LAST);
 
    if (SUCCEEDED(hr) && (share_mode == STGM_SHARE_DENY_READ || share_mode == STGM_SHARE_EXCLUSIVE))
        hr = StorageImpl_LockOne(This, RANGELOCK_DENY_READ_FIRST, RANGELOCK_DENY_READ_LAST);
 
    if (SUCCEEDED(hr) && (share_mode == STGM_SHARE_DENY_WRITE || share_mode == STGM_SHARE_EXCLUSIVE))
        hr = StorageImpl_LockOne(This, RANGELOCK_DENY_WRITE_FIRST, RANGELOCK_DENY_WRITE_LAST);
 
    if (SUCCEEDED(hr) && (openFlags & STGM_NOSNAPSHOT) == STGM_NOSNAPSHOT)
        hr = StorageImpl_LockOne(This, RANGELOCK_NOSNAPSHOT_FIRST, RANGELOCK_NOSNAPSHOT_LAST);
 
    offset.QuadPart = RANGELOCK_CHECKLOCKS;
    cb.QuadPart = 1;
    StorageImpl_UnlockRegion(This, offset, cb, LOCK_ONLYONCE);
 
    return hr;
}

Referenced by StorageImpl_Construct().

StorageImpl_Invalidate()

static void StorageImpl_Invalidate ( StorageBaseImpl *  iface )

static

Definition at line 5177 of file storage32.c.

{
  StorageImpl *This = (StorageImpl*) iface;
 
  StorageBaseImpl_DeleteAll(&This->base);
 
  This->base.reverted = TRUE;
}

Referenced by StorageImpl_Destroy().

StorageImpl_LoadFileHeader()

static HRESULT StorageImpl_LoadFileHeader ( StorageImpl *  This )

static

Definition at line 2893 of file storage32.c.

{
  HRESULT hr;
  BYTE    headerBigBlock[HEADER_SIZE];
  int     index;
  ULARGE_INTEGER offset;
  DWORD bytes_read;
 
  TRACE("\n");
  /*
   * Get a pointer to the big block of data containing the header.
   */
  offset.u.HighPart = 0;
  offset.u.LowPart = 0;
  hr = StorageImpl_ReadAt(This, offset, headerBigBlock, HEADER_SIZE, &bytes_read);
  if (SUCCEEDED(hr) && bytes_read != HEADER_SIZE)
    hr = STG_E_FILENOTFOUND;
 
  /*
   * Extract the information from the header.
   */
  if (SUCCEEDED(hr))
  {
    /*
     * Check for the "magic number" signature and return an error if it is not
     * found.
     */
    if (memcmp(headerBigBlock, STORAGE_oldmagic, sizeof(STORAGE_oldmagic))==0)
    {
      return STG_E_OLDFORMAT;
    }
 
    if (memcmp(headerBigBlock, STORAGE_magic, sizeof(STORAGE_magic))!=0)
    {
      return STG_E_INVALIDHEADER;
    }
 
    StorageUtl_ReadWord(
      headerBigBlock,
      OFFSET_BIGBLOCKSIZEBITS,
      &This->bigBlockSizeBits);
 
    StorageUtl_ReadWord(
      headerBigBlock,
      OFFSET_SMALLBLOCKSIZEBITS,
      &This->smallBlockSizeBits);
 
    StorageUtl_ReadDWord(
      headerBigBlock,
      OFFSET_BBDEPOTCOUNT,
      &This->bigBlockDepotCount);
 
    StorageUtl_ReadDWord(
      headerBigBlock,
      OFFSET_ROOTSTARTBLOCK,
      &This->rootStartBlock);
 
    StorageUtl_ReadDWord(
      headerBigBlock,
      OFFSET_TRANSACTIONSIG,
      &This->transactionSig);
 
    StorageUtl_ReadDWord(
      headerBigBlock,
      OFFSET_SMALLBLOCKLIMIT,
      &This->smallBlockLimit);
 
    StorageUtl_ReadDWord(
      headerBigBlock,
      OFFSET_SBDEPOTSTART,
      &This->smallBlockDepotStart);
 
    StorageUtl_ReadDWord(
      headerBigBlock,
      OFFSET_EXTBBDEPOTSTART,
      &This->extBigBlockDepotStart);
 
    StorageUtl_ReadDWord(
      headerBigBlock,
      OFFSET_EXTBBDEPOTCOUNT,
      &This->extBigBlockDepotCount);
 
    for (index = 0; index < COUNT_BBDEPOTINHEADER; index ++)
    {
      StorageUtl_ReadDWord(
        headerBigBlock,
        OFFSET_BBDEPOTSTART + (sizeof(ULONG)*index),
        &(This->bigBlockDepotStart[index]));
    }
 
    /*
     * Make the bitwise arithmetic to get the size of the blocks in bytes.
     */
    This->bigBlockSize   = 0x000000001 << (DWORD)This->bigBlockSizeBits;
    This->smallBlockSize = 0x000000001 << (DWORD)This->smallBlockSizeBits;
 
    /*
     * Right now, the code is making some assumptions about the size of the
     * blocks, just make sure they are what we're expecting.
     */
    if ((This->bigBlockSize != MIN_BIG_BLOCK_SIZE && This->bigBlockSize != MAX_BIG_BLOCK_SIZE) ||
    This->smallBlockSize != DEF_SMALL_BLOCK_SIZE ||
    This->smallBlockLimit != LIMIT_TO_USE_SMALL_BLOCK)
    {
    FIXME("Broken OLE storage file? bigblock=0x%x, smallblock=0x%x, sblimit=0x%x\n",
        This->bigBlockSize, This->smallBlockSize, This->smallBlockLimit);
    hr = STG_E_INVALIDHEADER;
    }
    else
    hr = S_OK;
  }
 
  return hr;
}

Referenced by StorageImpl_Refresh().

StorageImpl_LockOne()

static HRESULT StorageImpl_LockOne ( StorageImpl *  This, ULONG  start, ULONG  end  )

static

Definition at line 5041 of file storage32.c.

{
    HRESULT hr=S_OK;
    int i, j;
    ULARGE_INTEGER offset, cb;
 
    cb.QuadPart = 1;
 
    for (i=start; i<=end; i++)
    {
        offset.QuadPart = i;
        hr = StorageImpl_LockRegion(This, offset, cb, LOCK_ONLYONCE, NULL);
        if (hr != STG_E_ACCESSDENIED && hr != STG_E_LOCKVIOLATION)
            break;
    }
 
    if (SUCCEEDED(hr))
    {
        for (j = 0; j < ARRAY_SIZE(This->locked_bytes); j++)
        {
            if (This->locked_bytes[j] == 0)
            {
                This->locked_bytes[j] = i;
                break;
            }
        }
    }
 
    return hr;
}

Referenced by StorageImpl_GrabLocks().

StorageImpl_LockRegion()

static HRESULT StorageImpl_LockRegion ( StorageImpl *  This, ULARGE_INTEGER  offset, ULARGE_INTEGER  cb, DWORD  dwLockType, BOOL *  supported  )

static

Definition at line 4888 of file storage32.c.

{
    if ((dwLockType & This->locks_supported) == 0)
    {
        if (supported) *supported = FALSE;
        return S_OK;
    }
 
    if (supported) *supported = TRUE;
    return ILockBytes_LockRegion(This->lockBytes, offset, cb, dwLockType);
}

Referenced by StorageImpl_CheckLockRange(), StorageImpl_LockOne(), and StorageImpl_LockRegionSync().

StorageImpl_LockRegionSync()

static HRESULT StorageImpl_LockRegionSync ( StorageImpl *  This, ULARGE_INTEGER  offset, ULARGE_INTEGER  cb, DWORD  dwLockType, BOOL *  supported  )

static

Definition at line 4911 of file storage32.c.

{
    HRESULT hr;
    int delay = 0;
    DWORD start_time = GetTickCount();
    DWORD last_sanity_check = start_time;
    ULARGE_INTEGER sanity_offset, sanity_cb;
 
    sanity_offset.QuadPart = RANGELOCK_UNK1_FIRST;
    sanity_cb.QuadPart = RANGELOCK_UNK1_LAST - RANGELOCK_UNK1_FIRST + 1;
 
    do
    {
        hr = StorageImpl_LockRegion(This, offset, cb, dwLockType, supported);
 
        if (hr == STG_E_ACCESSDENIED || hr == STG_E_LOCKVIOLATION)
        {
            DWORD current_time = GetTickCount();
            if (current_time - start_time >= 20000)
            {
                /* timeout */
                break;
            }
            if (current_time - last_sanity_check >= 500)
            {
                /* Any storage implementation with the file open in a
                 * shared mode should not lock these bytes for writing. However,
                 * some programs (LibreOffice Writer) will keep ALL bytes locked
                 * when opening in exclusive mode. We can use a read lock to
                 * detect this case early, and not hang a full 20 seconds.
                 *
                 * This can collide with another attempt to open the file in
                 * exclusive mode, but it's unlikely, and someone would fail anyway. */
                hr = StorageImpl_LockRegion(This, sanity_offset, sanity_cb, WINE_LOCK_READ, NULL);
                if (hr == STG_E_ACCESSDENIED || hr == STG_E_LOCKVIOLATION)
                    break;
                if (SUCCEEDED(hr))
                {
                    StorageImpl_UnlockRegion(This, sanity_offset, sanity_cb, WINE_LOCK_READ);
                    hr = STG_E_ACCESSDENIED;
                }
 
                last_sanity_check = current_time;
            }
            Sleep(delay);
            if (delay < 150) delay++;
        }
    } while (hr == STG_E_ACCESSDENIED || hr == STG_E_LOCKVIOLATION);
 
    return hr;
}

Referenced by StorageImpl_GrabLocks(), and StorageImpl_LockTransaction().

StorageImpl_LockTransaction()

static HRESULT StorageImpl_LockTransaction ( StorageBaseImpl *  base, BOOL  write  )

static

Definition at line 4964 of file storage32.c.

{
  StorageImpl *This = (StorageImpl*)base;
  HRESULT hr;
  ULARGE_INTEGER offset, cb;
 
  if (write)
  {
    /* Synchronous grab of second priority range, the commit lock, and the
     * lock-checking lock. */
    offset.QuadPart = RANGELOCK_TRANSACTION_FIRST;
    cb.QuadPart = RANGELOCK_TRANSACTION_LAST - RANGELOCK_TRANSACTION_FIRST + 1;
  }
  else
  {
    offset.QuadPart = RANGELOCK_COMMIT;
    cb.QuadPart = 1;
  }
 
  hr = StorageImpl_LockRegionSync(This, offset, cb, LOCK_ONLYONCE, NULL);
 
  return hr;
}

StorageImpl_ReadAt()

static HRESULT StorageImpl_ReadAt ( StorageImpl *  This, ULARGE_INTEGER  offset, void *  buffer, ULONG  size, ULONG *  bytesRead  )

static

Definition at line 2870 of file storage32.c.

{
    return ILockBytes_ReadAt(This->lockBytes,offset,buffer,size,bytesRead);
}

Referenced by BlockChainStream_ReadAt(), StorageImpl_GetTransactionSig(), StorageImpl_LoadFileHeader(), StorageImpl_ReadBigBlock(), StorageImpl_ReadDWordFromBigBlock(), and StorageImpl_SaveFileHeader().

StorageImpl_ReadBigBlock()

static HRESULT StorageImpl_ReadBigBlock ( StorageImpl *  This, ULONG  blockIndex, void *  buffer, ULONG *  out_read  )

static

Definition at line 3546 of file storage32.c.

{
  ULARGE_INTEGER ulOffset;
  DWORD  read=0;
  HRESULT hr;
 
  ulOffset.QuadPart = StorageImpl_GetBigBlockOffset(This, blockIndex);
 
  hr = StorageImpl_ReadAt(This, ulOffset, buffer, This->bigBlockSize, &read);
 
  if (SUCCEEDED(hr) &&  read < This->bigBlockSize)
  {
    /* File ends during this block; fill the rest with 0's. */
    memset((LPBYTE)buffer+read, 0, This->bigBlockSize-read);
  }
 
  if (out_read) *out_read = read;
 
  return hr;
}

Referenced by BlockChainStream_ReadAt(), BlockChainStream_WriteAt(), Storage32Impl_GetExtDepotBlock(), StorageImpl_GetNextBlockInChain(), and StorageImpl_GetNextFreeBigBlock().

StorageImpl_ReadDirEntry()

static HRESULT StorageImpl_ReadDirEntry ( StorageImpl *  This, DirRef  index, DirEntry *  buffer  )

static

Definition at line 3428 of file storage32.c.

{
  BYTE           currentEntry[RAW_DIRENTRY_SIZE];
  HRESULT        readRes;
 
  readRes = StorageImpl_ReadRawDirEntry(This, index, currentEntry);
 
  if (SUCCEEDED(readRes))
  {
    memset(buffer->name, 0, sizeof(buffer->name));
    memcpy(
      buffer->name,
      (WCHAR *)currentEntry+OFFSET_PS_NAME,
      DIRENTRY_NAME_BUFFER_LEN );
    TRACE("storage name: %s\n", debugstr_w(buffer->name));
 
    memcpy(&buffer->stgType, currentEntry + OFFSET_PS_STGTYPE, 1);
 
    StorageUtl_ReadWord(
      currentEntry,
      OFFSET_PS_NAMELENGTH,
      &buffer->sizeOfNameString);
 
    StorageUtl_ReadDWord(
      currentEntry,
      OFFSET_PS_LEFTCHILD,
      &buffer->leftChild);
 
    StorageUtl_ReadDWord(
      currentEntry,
      OFFSET_PS_RIGHTCHILD,
      &buffer->rightChild);
 
    StorageUtl_ReadDWord(
      currentEntry,
      OFFSET_PS_DIRROOT,
      &buffer->dirRootEntry);
 
    StorageUtl_ReadGUID(
      currentEntry,
      OFFSET_PS_GUID,
      &buffer->clsid);
 
    StorageUtl_ReadDWord(
      currentEntry,
      OFFSET_PS_CTIMELOW,
      &buffer->ctime.dwLowDateTime);
 
    StorageUtl_ReadDWord(
      currentEntry,
      OFFSET_PS_CTIMEHIGH,
      &buffer->ctime.dwHighDateTime);
 
    StorageUtl_ReadDWord(
      currentEntry,
      OFFSET_PS_MTIMELOW,
      &buffer->mtime.dwLowDateTime);
 
    StorageUtl_ReadDWord(
      currentEntry,
      OFFSET_PS_MTIMEHIGH,
      &buffer->mtime.dwHighDateTime);
 
    StorageUtl_ReadDWord(
      currentEntry,
      OFFSET_PS_STARTBLOCK,
      &buffer->startingBlock);
 
    StorageUtl_ReadDWord(
      currentEntry,
      OFFSET_PS_SIZE,
      &buffer->size.u.LowPart);
 
    if (This->bigBlockSize < 4096)
    {
      /* Version 3 files may have junk in the high part of size. */
      buffer->size.u.HighPart = 0;
    }
    else
    {
      StorageUtl_ReadDWord(
        currentEntry,
        OFFSET_PS_SIZE_HIGH,
        &buffer->size.u.HighPart);
    }
  }
 
  return readRes;
}

Referenced by BlockChainStream_Enlarge(), BlockChainStream_GetHeadOfChain(), BlockChainStream_GetSize(), BlockChainStream_Shrink(), SmallBlockChainStream_Enlarge(), SmallBlockChainStream_GetHeadOfChain(), SmallBlockChainStream_GetNextFreeBlock(), SmallBlockChainStream_GetSize(), SmallBlockChainStream_Shrink(), Storage32Impl_BigBlocksToSmallBlocks(), Storage32Impl_SmallBlocksToBigBlocks(), StorageImpl_BaseReadDirEntry(), StorageImpl_Refresh(), StorageImpl_StreamLink(), StorageImpl_StreamReadAt(), StorageImpl_StreamSetSize(), and StorageImpl_StreamWriteAt().

StorageImpl_ReadDWordFromBigBlock()

static BOOL StorageImpl_ReadDWordFromBigBlock ( StorageImpl *  This, ULONG  blockIndex, ULONG  offset, DWORD *  value  )

static

Definition at line 3571 of file storage32.c.

{
  ULARGE_INTEGER ulOffset;
  DWORD  read;
  DWORD  tmp;
 
  ulOffset.QuadPart = StorageImpl_GetBigBlockOffset(This, blockIndex);
  ulOffset.QuadPart += offset;
 
  StorageImpl_ReadAt(This, ulOffset, &tmp, sizeof(DWORD), &read);
  *value = lendian32toh(tmp);
  return (read == sizeof(DWORD));
}

Referenced by Storage32Impl_GetNextExtendedBlock().

StorageImpl_ReadRawDirEntry()

static HRESULT StorageImpl_ReadRawDirEntry ( StorageImpl *  This, ULONG  index, BYTE *  buffer  )

static

Definition at line 3171 of file storage32.c.

{
  ULARGE_INTEGER offset;
  HRESULT hr;
  ULONG bytesRead;
 
  offset.QuadPart  = (ULONGLONG)index * RAW_DIRENTRY_SIZE;
 
  hr = BlockChainStream_ReadAt(
                    This->rootBlockChain,
                    offset,
                    RAW_DIRENTRY_SIZE,
                    buffer,
                    &bytesRead);
 
  if (bytesRead != RAW_DIRENTRY_SIZE)
    return STG_E_READFAULT;
 
  return hr;
}

Referenced by StorageImpl_CreateDirEntry(), and StorageImpl_ReadDirEntry().

StorageImpl_Refresh()

static HRESULT StorageImpl_Refresh ( StorageImpl *  This, BOOL  new_object, BOOL  create  )

static

Definition at line 4623 of file storage32.c.

{
  HRESULT hr=S_OK;
  DirEntry currentEntry;
  DirRef      currentEntryRef;
  BlockChainStream *blockChainStream;
 
  if (create)
  {
    ULARGE_INTEGER size;
    BYTE bigBlockBuffer[MAX_BIG_BLOCK_SIZE];
 
    /* Discard any existing data. */
    size.QuadPart = 0;
    ILockBytes_SetSize(This->lockBytes, size);
 
    /*
     * Initialize all header variables:
     * - The big block depot consists of one block and it is at block 0
     * - The directory table starts at block 1
     * - There is no small block depot
     */
    memset( This->bigBlockDepotStart,
            BLOCK_UNUSED,
            sizeof(This->bigBlockDepotStart));
 
    This->bigBlockDepotCount    = 1;
    This->bigBlockDepotStart[0] = 0;
    This->rootStartBlock        = 1;
    This->smallBlockLimit       = LIMIT_TO_USE_SMALL_BLOCK;
    This->smallBlockDepotStart  = BLOCK_END_OF_CHAIN;
    if (This->bigBlockSize == 4096)
      This->bigBlockSizeBits    = MAX_BIG_BLOCK_SIZE_BITS;
    else
      This->bigBlockSizeBits    = MIN_BIG_BLOCK_SIZE_BITS;
    This->smallBlockSizeBits    = DEF_SMALL_BLOCK_SIZE_BITS;
    This->extBigBlockDepotStart = BLOCK_END_OF_CHAIN;
    This->extBigBlockDepotCount = 0;
 
    StorageImpl_SaveFileHeader(This);
 
    /*
     * Add one block for the big block depot and one block for the directory table
     */
    size.u.HighPart = 0;
    size.u.LowPart  = This->bigBlockSize * 3;
    ILockBytes_SetSize(This->lockBytes, size);
 
    /*
     * Initialize the big block depot
     */
    memset(bigBlockBuffer, BLOCK_UNUSED, This->bigBlockSize);
    StorageUtl_WriteDWord(bigBlockBuffer, 0, BLOCK_SPECIAL);
    StorageUtl_WriteDWord(bigBlockBuffer, sizeof(ULONG), BLOCK_END_OF_CHAIN);
    StorageImpl_WriteBigBlock(This, 0, bigBlockBuffer);
  }
  else
  {
    /*
     * Load the header for the file.
     */
    hr = StorageImpl_LoadFileHeader(This);
 
    if (FAILED(hr))
    {
      return hr;
    }
  }
 
  /*
   * There is no block depot cached yet.
   */
  This->indexBlockDepotCached = 0xFFFFFFFF;
  This->indexExtBlockDepotCached = 0xFFFFFFFF;
 
  /*
   * Start searching for free blocks with block 0.
   */
  This->prevFreeBlock = 0;
 
  This->firstFreeSmallBlock = 0;
 
  /* Read the extended big block depot locations. */
  if (This->extBigBlockDepotCount != 0)
  {
    ULONG current_block = This->extBigBlockDepotStart;
    ULONG cache_size = This->extBigBlockDepotCount * 2;
    ULONG i;
 
    This->extBigBlockDepotLocations = HeapAlloc(GetProcessHeap(), 0, sizeof(ULONG) * cache_size);
    if (!This->extBigBlockDepotLocations)
    {
      return E_OUTOFMEMORY;
    }
 
    This->extBigBlockDepotLocationsSize = cache_size;
 
    for (i=0; i<This->extBigBlockDepotCount; i++)
    {
      if (current_block == BLOCK_END_OF_CHAIN)
      {
        WARN("File has too few extended big block depot blocks.\n");
        return STG_E_DOCFILECORRUPT;
      }
      This->extBigBlockDepotLocations[i] = current_block;
      current_block = Storage32Impl_GetNextExtendedBlock(This, current_block);
    }
  }
  else
  {
    This->extBigBlockDepotLocations = NULL;
    This->extBigBlockDepotLocationsSize = 0;
  }
 
  /*
   * Create the block chain abstractions.
   */
  if(!(blockChainStream =
       BlockChainStream_Construct(This, &This->rootStartBlock, DIRENTRY_NULL)))
  {
    return STG_E_READFAULT;
  }
  if (!new_object)
    BlockChainStream_Destroy(This->rootBlockChain);
  This->rootBlockChain = blockChainStream;
 
  if(!(blockChainStream =
       BlockChainStream_Construct(This, &This->smallBlockDepotStart,
                  DIRENTRY_NULL)))
  {
    return STG_E_READFAULT;
  }
  if (!new_object)
    BlockChainStream_Destroy(This->smallBlockDepotChain);
  This->smallBlockDepotChain = blockChainStream;
 
  /*
   * Write the root storage entry (memory only)
   */
  if (create)
  {
    static const WCHAR rootentryW[] = {'R','o','o','t',' ','E','n','t','r','y',0};
    DirEntry rootEntry;
    /*
     * Initialize the directory table
     */
    memset(&rootEntry, 0, sizeof(rootEntry));
    lstrcpyW(rootEntry.name, rootentryW);
    rootEntry.sizeOfNameString = sizeof(rootentryW);
    rootEntry.stgType          = STGTY_ROOT;
    rootEntry.leftChild        = DIRENTRY_NULL;
    rootEntry.rightChild       = DIRENTRY_NULL;
    rootEntry.dirRootEntry     = DIRENTRY_NULL;
    rootEntry.startingBlock    = BLOCK_END_OF_CHAIN;
    rootEntry.size.u.HighPart  = 0;
    rootEntry.size.u.LowPart   = 0;
 
    StorageImpl_WriteDirEntry(This, 0, &rootEntry);
  }
 
  /*
   * Find the ID of the root storage.
   */
  currentEntryRef = 0;
 
  do
  {
    hr = StorageImpl_ReadDirEntry(
                      This,
                      currentEntryRef,
                      &currentEntry);
 
    if (SUCCEEDED(hr))
    {
      if ( (currentEntry.sizeOfNameString != 0 ) &&
           (currentEntry.stgType          == STGTY_ROOT) )
      {
        This->base.storageDirEntry = currentEntryRef;
      }
    }
 
    currentEntryRef++;
 
  } while (SUCCEEDED(hr) && (This->base.storageDirEntry == DIRENTRY_NULL) );
 
  if (FAILED(hr))
  {
    return STG_E_READFAULT;
  }
 
  /*
   * Create the block chain abstraction for the small block root chain.
   */
  if(!(blockChainStream =
       BlockChainStream_Construct(This, NULL, This->base.storageDirEntry)))
  {
    return STG_E_READFAULT;
  }
  if (!new_object)
    BlockChainStream_Destroy(This->smallBlockRootChain);
  This->smallBlockRootChain = blockChainStream;
 
  if (!new_object)
  {
    int i;
    for (i=0; i<BLOCKCHAIN_CACHE_SIZE; i++)
    {
      BlockChainStream_Destroy(This->blockChainCache[i]);
      This->blockChainCache[i] = NULL;
    }
  }
 
  return hr;
}

Referenced by StorageImpl_Construct(), and StorageImpl_GetTransactionSig().

StorageImpl_SaveFileHeader()

static void StorageImpl_SaveFileHeader ( StorageImpl *  This )

static

Definition at line 3014 of file storage32.c.

{
  BYTE   headerBigBlock[HEADER_SIZE];
  int    index;
  HRESULT hr;
  ULARGE_INTEGER offset;
  DWORD bytes_read, bytes_written;
  DWORD major_version, dirsectorcount;
 
  /*
   * Get a pointer to the big block of data containing the header.
   */
  offset.u.HighPart = 0;
  offset.u.LowPart = 0;
  hr = StorageImpl_ReadAt(This, offset, headerBigBlock, HEADER_SIZE, &bytes_read);
  if (SUCCEEDED(hr) && bytes_read != HEADER_SIZE)
    hr = STG_E_FILENOTFOUND;
 
  if (This->bigBlockSizeBits == 0x9)
    major_version = 3;
  else if (This->bigBlockSizeBits == 0xc)
    major_version = 4;
  else
  {
    ERR("invalid big block shift 0x%x\n", This->bigBlockSizeBits);
    major_version = 4;
  }
 
  /*
   * If the block read failed, the file is probably new.
   */
  if (FAILED(hr))
  {
    /*
     * Initialize for all unknown fields.
     */
    memset(headerBigBlock, 0, HEADER_SIZE);
 
    /*
     * Initialize the magic number.
     */
    memcpy(headerBigBlock, STORAGE_magic, sizeof(STORAGE_magic));
  }
 
  /*
   * Write the information to the header.
   */
  StorageUtl_WriteWord(
    headerBigBlock,
    OFFSET_MINORVERSION,
    0x3e);
 
  StorageUtl_WriteWord(
    headerBigBlock,
    OFFSET_MAJORVERSION,
    major_version);
 
  StorageUtl_WriteWord(
    headerBigBlock,
    OFFSET_BYTEORDERMARKER,
    (WORD)-2);
 
  StorageUtl_WriteWord(
    headerBigBlock,
    OFFSET_BIGBLOCKSIZEBITS,
    This->bigBlockSizeBits);
 
  StorageUtl_WriteWord(
    headerBigBlock,
    OFFSET_SMALLBLOCKSIZEBITS,
    This->smallBlockSizeBits);
 
  if (major_version >= 4)
  {
    if (This->rootBlockChain)
      dirsectorcount = BlockChainStream_GetCount(This->rootBlockChain);
    else
      /* This file is being created, and it will start out with one block. */
      dirsectorcount = 1;
  }
  else
    /* This field must be 0 in versions older than 4 */
    dirsectorcount = 0;
 
  StorageUtl_WriteDWord(
    headerBigBlock,
    OFFSET_DIRSECTORCOUNT,
    dirsectorcount);
 
  StorageUtl_WriteDWord(
    headerBigBlock,
    OFFSET_BBDEPOTCOUNT,
    This->bigBlockDepotCount);
 
  StorageUtl_WriteDWord(
    headerBigBlock,
    OFFSET_ROOTSTARTBLOCK,
    This->rootStartBlock);
 
  StorageUtl_WriteDWord(
    headerBigBlock,
    OFFSET_TRANSACTIONSIG,
    This->transactionSig);
 
  StorageUtl_WriteDWord(
    headerBigBlock,
    OFFSET_SMALLBLOCKLIMIT,
    This->smallBlockLimit);
 
  StorageUtl_WriteDWord(
    headerBigBlock,
    OFFSET_SBDEPOTSTART,
    This->smallBlockDepotStart);
 
  StorageUtl_WriteDWord(
    headerBigBlock,
    OFFSET_SBDEPOTCOUNT,
    This->smallBlockDepotChain ?
     BlockChainStream_GetCount(This->smallBlockDepotChain) : 0);
 
  StorageUtl_WriteDWord(
    headerBigBlock,
    OFFSET_EXTBBDEPOTSTART,
    This->extBigBlockDepotStart);
 
  StorageUtl_WriteDWord(
    headerBigBlock,
    OFFSET_EXTBBDEPOTCOUNT,
    This->extBigBlockDepotCount);
 
  for (index = 0; index < COUNT_BBDEPOTINHEADER; index ++)
  {
    StorageUtl_WriteDWord(
      headerBigBlock,
      OFFSET_BBDEPOTSTART + (sizeof(ULONG)*index),
      (This->bigBlockDepotStart[index]));
  }
 
  /*
   * Write the big block back to the file.
   */
  StorageImpl_WriteAt(This, offset, headerBigBlock, HEADER_SIZE, &bytes_written);
}

Referenced by SmallBlockChainStream_GetNextFreeBlock(), StorageImpl_CreateDirEntry(), StorageImpl_GetNextFreeBigBlock(), StorageImpl_Refresh(), and StorageImpl_SetTransactionSig().

StorageImpl_SetNextBlockInChain()

static void StorageImpl_SetNextBlockInChain ( StorageImpl *  This, ULONG  blockIndex, ULONG  nextBlock  )

static

Definition at line 4121 of file storage32.c.

{
  ULONG offsetInDepot    = blockIndex * sizeof (ULONG);
  ULONG depotBlockCount  = offsetInDepot / This->bigBlockSize;
  ULONG depotBlockOffset = offsetInDepot % This->bigBlockSize;
  ULONG depotBlockIndexPos;
 
  assert(depotBlockCount < This->bigBlockDepotCount);
  assert(blockIndex != nextBlock);
 
  if (blockIndex == (RANGELOCK_FIRST / This->bigBlockSize) - 1)
    /* This should never happen (storage file format spec forbids it), but
     * older versions of Wine may have generated broken files. We don't want to
     * assert and potentially lose data, but we do want to know if this ever
     * happens in a newly-created file. */
    ERR("Using range lock page\n");
 
  if (depotBlockCount < COUNT_BBDEPOTINHEADER)
  {
    depotBlockIndexPos = This->bigBlockDepotStart[depotBlockCount];
  }
  else
  {
    /*
     * We have to look in the extended depot.
     */
    depotBlockIndexPos = Storage32Impl_GetExtDepotBlock(This, depotBlockCount);
  }
 
  StorageImpl_WriteDWordToBigBlock(This, depotBlockIndexPos, depotBlockOffset,
                        nextBlock);
  /*
   * Update the cached block depot, if necessary.
   */
  if (depotBlockCount == This->indexBlockDepotCached)
  {
    This->blockDepotCached[depotBlockOffset/sizeof(ULONG)] = nextBlock;
  }
}

Referenced by BlockChainStream_Enlarge(), BlockChainStream_Shrink(), StorageImpl_FreeBigBlock(), and StorageImpl_GetNextFreeBigBlock().

StorageImpl_SetTransactionSig()

static HRESULT StorageImpl_SetTransactionSig ( StorageBaseImpl *  base, ULONG  value  )

static

Definition at line 4877 of file storage32.c.

{
  StorageImpl *This = (StorageImpl*)base;
 
  This->transactionSig = value;
  StorageImpl_SaveFileHeader(This);
 
  return S_OK;
}

StorageImpl_StreamLink()

static HRESULT StorageImpl_StreamLink ( StorageBaseImpl *  base, DirRef  dst, DirRef  src  )

static

Definition at line 4599 of file storage32.c.

{
  StorageImpl *This = (StorageImpl*)base;
  DirEntry dst_data, src_data;
  HRESULT hr;
 
  hr = StorageImpl_ReadDirEntry(This, dst, &dst_data);
 
  if (SUCCEEDED(hr))
    hr = StorageImpl_ReadDirEntry(This, src, &src_data);
 
  if (SUCCEEDED(hr))
  {
    StorageImpl_DeleteCachedBlockChainStream(This, src);
    dst_data.startingBlock = src_data.startingBlock;
    dst_data.size = src_data.size;
 
    hr = StorageImpl_WriteDirEntry(This, dst, &dst_data);
  }
 
  return hr;
}

StorageImpl_StreamReadAt()

static HRESULT StorageImpl_StreamReadAt ( StorageBaseImpl *  base, DirRef  index, ULARGE_INTEGER  offset, ULONG  size, void *  buffer, ULONG *  bytesRead  )

static

Definition at line 4411 of file storage32.c.

{
  StorageImpl *This = (StorageImpl*)base;
  DirEntry data;
  HRESULT hr;
  ULONG bytesToRead;
 
  hr = StorageImpl_ReadDirEntry(This, index, &data);
  if (FAILED(hr)) return hr;
 
  if (data.size.QuadPart == 0)
  {
    *bytesRead = 0;
    return S_OK;
  }
 
  if (offset.QuadPart + size > data.size.QuadPart)
  {
    bytesToRead = data.size.QuadPart - offset.QuadPart;
  }
  else
  {
    bytesToRead = size;
  }
 
  if (data.size.QuadPart < LIMIT_TO_USE_SMALL_BLOCK)
  {
    SmallBlockChainStream *stream;
 
    stream = SmallBlockChainStream_Construct(This, NULL, index);
    if (!stream) return E_OUTOFMEMORY;
 
    hr = SmallBlockChainStream_ReadAt(stream, offset, bytesToRead, buffer, bytesRead);
 
    SmallBlockChainStream_Destroy(stream);
 
    return hr;
  }
  else
  {
    BlockChainStream *stream = NULL;
 
    stream = *StorageImpl_GetCachedBlockChainStream(This, index);
    if (!stream) return E_OUTOFMEMORY;
 
    hr = BlockChainStream_ReadAt(stream, offset, bytesToRead, buffer, bytesRead);
 
    return hr;
  }
}

StorageImpl_StreamSetSize()

static HRESULT StorageImpl_StreamSetSize ( StorageBaseImpl *  base, DirRef  index, ULARGE_INTEGER  newsize  )

static

Definition at line 4463 of file storage32.c.

{
  StorageImpl *This = (StorageImpl*)base;
  DirEntry data;
  HRESULT hr;
  SmallBlockChainStream *smallblock=NULL;
  BlockChainStream **pbigblock=NULL, *bigblock=NULL;
 
  hr = StorageImpl_ReadDirEntry(This, index, &data);
  if (FAILED(hr)) return hr;
 
  /* In simple mode keep the stream size above the small block limit */
  if (This->base.openFlags & STGM_SIMPLE)
    newsize.QuadPart = max(newsize.QuadPart, LIMIT_TO_USE_SMALL_BLOCK);
 
  if (data.size.QuadPart == newsize.QuadPart)
    return S_OK;
 
  /* Create a block chain object of the appropriate type */
  if (data.size.QuadPart == 0)
  {
    if (newsize.QuadPart < LIMIT_TO_USE_SMALL_BLOCK)
    {
      smallblock = SmallBlockChainStream_Construct(This, NULL, index);
      if (!smallblock) return E_OUTOFMEMORY;
    }
    else
    {
      pbigblock = StorageImpl_GetCachedBlockChainStream(This, index);
      bigblock = *pbigblock;
      if (!bigblock) return E_OUTOFMEMORY;
    }
  }
  else if (data.size.QuadPart < LIMIT_TO_USE_SMALL_BLOCK)
  {
    smallblock = SmallBlockChainStream_Construct(This, NULL, index);
    if (!smallblock) return E_OUTOFMEMORY;
  }
  else
  {
    pbigblock = StorageImpl_GetCachedBlockChainStream(This, index);
    bigblock = *pbigblock;
    if (!bigblock) return E_OUTOFMEMORY;
  }
 
  /* Change the block chain type if necessary. */
  if (smallblock && newsize.QuadPart >= LIMIT_TO_USE_SMALL_BLOCK)
  {
    bigblock = Storage32Impl_SmallBlocksToBigBlocks(This, &smallblock);
    if (!bigblock)
    {
      SmallBlockChainStream_Destroy(smallblock);
      return E_FAIL;
    }
 
    pbigblock = StorageImpl_GetFreeBlockChainCacheEntry(This);
    *pbigblock = bigblock;
  }
  else if (bigblock && newsize.QuadPart < LIMIT_TO_USE_SMALL_BLOCK)
  {
    smallblock = Storage32Impl_BigBlocksToSmallBlocks(This, pbigblock, newsize);
    if (!smallblock)
      return E_FAIL;
  }
 
  /* Set the size of the block chain. */
  if (smallblock)
  {
    SmallBlockChainStream_SetSize(smallblock, newsize);
    SmallBlockChainStream_Destroy(smallblock);
  }
  else
  {
    BlockChainStream_SetSize(bigblock, newsize);
  }
 
  /* Set the size in the directory entry. */
  hr = StorageImpl_ReadDirEntry(This, index, &data);
  if (SUCCEEDED(hr))
  {
    data.size = newsize;
 
    hr = StorageImpl_WriteDirEntry(This, index, &data);
  }
  return hr;
}

Referenced by StorageImpl_StreamWriteAt().

StorageImpl_StreamWriteAt()

static HRESULT StorageImpl_StreamWriteAt ( StorageBaseImpl *  base, DirRef  index, ULARGE_INTEGER  offset, ULONG  size, const void *  buffer, ULONG *  bytesWritten  )

static

Definition at line 4551 of file storage32.c.

{
  StorageImpl *This = (StorageImpl*)base;
  DirEntry data;
  HRESULT hr;
  ULARGE_INTEGER newSize;
 
  hr = StorageImpl_ReadDirEntry(This, index, &data);
  if (FAILED(hr)) return hr;
 
  /* Grow the stream if necessary */
  newSize.QuadPart = offset.QuadPart + size;
 
  if (newSize.QuadPart > data.size.QuadPart)
  {
    hr = StorageImpl_StreamSetSize(base, index, newSize);
    if (FAILED(hr))
      return hr;
 
    hr = StorageImpl_ReadDirEntry(This, index, &data);
    if (FAILED(hr)) return hr;
  }
 
  if (data.size.QuadPart < LIMIT_TO_USE_SMALL_BLOCK)
  {
    SmallBlockChainStream *stream;
 
    stream = SmallBlockChainStream_Construct(This, NULL, index);
    if (!stream) return E_OUTOFMEMORY;
 
    hr = SmallBlockChainStream_WriteAt(stream, offset, size, buffer, bytesWritten);
 
    SmallBlockChainStream_Destroy(stream);
 
    return hr;
  }
  else
  {
    BlockChainStream *stream;
 
    stream = *StorageImpl_GetCachedBlockChainStream(This, index);
    if (!stream) return E_OUTOFMEMORY;
 
    return BlockChainStream_WriteAt(stream, offset, size, buffer, bytesWritten);
  }
}

StorageImpl_UnlockRegion()

static HRESULT StorageImpl_UnlockRegion ( StorageImpl *  This, ULARGE_INTEGER  offset, ULARGE_INTEGER  cb, DWORD  dwLockType  )

static

Definition at line 4901 of file storage32.c.

{
    if ((dwLockType & This->locks_supported) == 0)
        return S_OK;
 
    return ILockBytes_UnlockRegion(This->lockBytes, offset, cb, dwLockType);
}

Referenced by StorageImpl_CheckLockRange(), StorageImpl_Destroy(), StorageImpl_GrabLocks(), StorageImpl_LockRegionSync(), and StorageImpl_UnlockTransaction().

StorageImpl_UnlockTransaction()

static HRESULT StorageImpl_UnlockTransaction ( StorageBaseImpl *  base, BOOL  write  )

static

Definition at line 4988 of file storage32.c.

{
  StorageImpl *This = (StorageImpl*)base;
  HRESULT hr;
  ULARGE_INTEGER offset, cb;
 
  if (write)
  {
    offset.QuadPart = RANGELOCK_TRANSACTION_FIRST;
    cb.QuadPart = RANGELOCK_TRANSACTION_LAST - RANGELOCK_TRANSACTION_FIRST + 1;
  }
  else
  {
    offset.QuadPart = RANGELOCK_COMMIT;
    cb.QuadPart = 1;
  }
 
  hr = StorageImpl_UnlockRegion(This, offset, cb, LOCK_ONLYONCE);
 
  return hr;
}

StorageImpl_WriteAt()

static HRESULT StorageImpl_WriteAt ( StorageImpl *  This, ULARGE_INTEGER  offset, const void *  buffer, const ULONG  size, ULONG *  bytesWritten  )

static

Definition at line 2879 of file storage32.c.

{
    return ILockBytes_WriteAt(This->lockBytes,offset,buffer,size,bytesWritten);
}

Referenced by BlockChainStream_WriteAt(), StorageImpl_SaveFileHeader(), StorageImpl_WriteBigBlock(), and StorageImpl_WriteDWordToBigBlock().

StorageImpl_WriteBigBlock()

static BOOL StorageImpl_WriteBigBlock ( StorageImpl *  This, ULONG  blockIndex, const void *  buffer  )

static

Definition at line 3589 of file storage32.c.

{
  ULARGE_INTEGER ulOffset;
  DWORD  wrote;
 
  ulOffset.QuadPart = StorageImpl_GetBigBlockOffset(This, blockIndex);
 
  StorageImpl_WriteAt(This, ulOffset, buffer, This->bigBlockSize, &wrote);
  return (wrote == This->bigBlockSize);
}

Referenced by BlockChainStream_Flush(), BlockChainStream_GetBlockAtOffset(), Storage32Impl_AddBlockDepot(), Storage32Impl_AddExtBlockDepot(), and StorageImpl_Refresh().

StorageImpl_WriteDirEntry()

static HRESULT StorageImpl_WriteDirEntry ( StorageImpl *  This, DirRef  index, const DirEntry *  buffer  )

static

Definition at line 3524 of file storage32.c.

{
  BYTE currentEntry[RAW_DIRENTRY_SIZE];
 
  UpdateRawDirEntry(currentEntry, buffer);
 
  return StorageImpl_WriteRawDirEntry(This, index, currentEntry);
}

Referenced by BlockChainStream_Enlarge(), BlockChainStream_Shrink(), SmallBlockChainStream_Enlarge(), SmallBlockChainStream_GetNextFreeBlock(), SmallBlockChainStream_Shrink(), Storage32Impl_BigBlocksToSmallBlocks(), Storage32Impl_SmallBlocksToBigBlocks(), StorageImpl_BaseWriteDirEntry(), StorageImpl_Refresh(), StorageImpl_StreamLink(), and StorageImpl_StreamSetSize().

StorageImpl_WriteDWordToBigBlock()

static BOOL StorageImpl_WriteDWordToBigBlock ( StorageImpl *  This, ULONG  blockIndex, ULONG  offset, DWORD  value  )

static

Definition at line 3603 of file storage32.c.

{
  ULARGE_INTEGER ulOffset;
  DWORD  wrote;
 
  ulOffset.QuadPart = StorageImpl_GetBigBlockOffset(This, blockIndex);
  ulOffset.QuadPart += offset;
 
  value = htole32(value);
  StorageImpl_WriteAt(This, ulOffset, &value, sizeof(DWORD), &wrote);
  return (wrote == sizeof(DWORD));
}

Referenced by Storage32Impl_AddExtBlockDepot(), Storage32Impl_SetExtDepotBlock(), and StorageImpl_SetNextBlockInChain().

StorageImpl_WriteRawDirEntry()

static HRESULT StorageImpl_WriteRawDirEntry ( StorageImpl *  This, ULONG  index, const BYTE *  buffer  )

static

Definition at line 3199 of file storage32.c.

{
  ULARGE_INTEGER offset;
  ULONG bytesRead;
 
  offset.QuadPart  = (ULONGLONG)index * RAW_DIRENTRY_SIZE;
 
  return BlockChainStream_WriteAt(
                    This->rootBlockChain,
                    offset,
                    RAW_DIRENTRY_SIZE,
                    buffer,
                    &bytesRead);
}

Referenced by StorageImpl_CreateDirEntry(), StorageImpl_DestroyDirEntry(), and StorageImpl_WriteDirEntry().

StorageInternalImpl_Commit()

static HRESULT WINAPI StorageInternalImpl_Commit ( IStorage *  iface, DWORD  grfCommitFlags  )

static

Definition at line 5500 of file storage32.c.

{
  StorageBaseImpl* This = impl_from_IStorage(iface);
  TRACE("(%p,%x)\n", iface, grfCommitFlags);
  return StorageBaseImpl_Flush(This);
}

StorageInternalImpl_Construct()

static StorageInternalImpl * StorageInternalImpl_Construct ( StorageBaseImpl *  parentStorage, DWORD  openFlags, DirRef  storageDirEntry  )

static

Definition at line 5566 of file storage32.c.

{
  StorageInternalImpl* newStorage;
 
  newStorage = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(StorageInternalImpl));
 
  if (newStorage!=0)
  {
    list_init(&newStorage->base.strmHead);
 
    list_init(&newStorage->base.storageHead);
 
    /*
     * Initialize the virtual function table.
     */
    newStorage->base.IStorage_iface.lpVtbl = &StorageInternalImpl_Vtbl;
    newStorage->base.IPropertySetStorage_iface.lpVtbl = &IPropertySetStorage_Vtbl;
    newStorage->base.baseVtbl = &StorageInternalImpl_BaseVtbl;
    newStorage->base.openFlags = (openFlags & ~STGM_CREATE);
 
    newStorage->base.reverted = FALSE;
 
    newStorage->base.ref = 1;
 
    newStorage->parentStorage = parentStorage;
 
    /*
     * Keep a reference to the directory entry of this storage
     */
    newStorage->base.storageDirEntry = storageDirEntry;
 
    newStorage->base.create = FALSE;
 
    return newStorage;
  }
 
  return 0;
}

Referenced by StorageBaseImpl_OpenStorage().

StorageInternalImpl_CreateDirEntry()

static HRESULT StorageInternalImpl_CreateDirEntry ( StorageBaseImpl *  base, const DirEntry *  newData, DirRef *  index  )

static

Definition at line 5401 of file storage32.c.

{
  StorageInternalImpl* This = (StorageInternalImpl*) base;
 
  return StorageBaseImpl_CreateDirEntry(This->parentStorage,
    newData, index);
}

StorageInternalImpl_Destroy()

static void StorageInternalImpl_Destroy ( StorageBaseImpl *  iface )

static

Definition at line 5378 of file storage32.c.

{
  StorageInternalImpl* This = (StorageInternalImpl*) iface;
 
  StorageInternalImpl_Invalidate(&This->base);
 
  HeapFree(GetProcessHeap(), 0, This);
}

StorageInternalImpl_DestroyDirEntry()

static HRESULT StorageInternalImpl_DestroyDirEntry ( StorageBaseImpl *  base, DirRef  index  )

static

Definition at line 5428 of file storage32.c.

{
  StorageInternalImpl* This = (StorageInternalImpl*) base;
 
  return StorageBaseImpl_DestroyDirEntry(This->parentStorage,
    index);
}

StorageInternalImpl_Flush()

static HRESULT StorageInternalImpl_Flush ( StorageBaseImpl *  iface )

static

Definition at line 5387 of file storage32.c.

{
  StorageInternalImpl* This = (StorageInternalImpl*) iface;
 
  return StorageBaseImpl_Flush(This->parentStorage);
}

StorageInternalImpl_GetFilename()

static HRESULT StorageInternalImpl_GetFilename ( StorageBaseImpl *  iface, LPWSTR *  result  )

static

Definition at line 5394 of file storage32.c.

{
  StorageInternalImpl* This = (StorageInternalImpl*) iface;
 
  return StorageBaseImpl_GetFilename(This->parentStorage, result);
}

StorageInternalImpl_GetTransactionSig()

static HRESULT StorageInternalImpl_GetTransactionSig ( StorageBaseImpl *  base, ULONG *  result, BOOL  refresh  )

static

Definition at line 5473 of file storage32.c.

{
  return E_NOTIMPL;
}

StorageInternalImpl_Invalidate()

static void StorageInternalImpl_Invalidate ( StorageBaseImpl *  base )

static

Definition at line 5360 of file storage32.c.

{
  StorageInternalImpl* This = (StorageInternalImpl*) base;
 
  if (!This->base.reverted)
  {
    TRACE("Storage invalidated (stg=%p)\n", This);
 
    This->base.reverted = TRUE;
 
    This->parentStorage = NULL;
 
    StorageBaseImpl_DeleteAll(&This->base);
 
    list_remove(&This->ParentListEntry);
  }
}

Referenced by StorageInternalImpl_Destroy().

StorageInternalImpl_LockTransaction()

static HRESULT StorageInternalImpl_LockTransaction ( StorageBaseImpl *  base, BOOL  write  )

static

Definition at line 5485 of file storage32.c.

{
  return E_NOTIMPL;
}

StorageInternalImpl_ReadDirEntry()

static HRESULT StorageInternalImpl_ReadDirEntry ( StorageBaseImpl *  base, DirRef  index, DirEntry *  data  )

static

Definition at line 5419 of file storage32.c.

{
  StorageInternalImpl* This = (StorageInternalImpl*) base;
 
  return StorageBaseImpl_ReadDirEntry(This->parentStorage,
    index, data);
}

StorageInternalImpl_Revert()

static HRESULT WINAPI StorageInternalImpl_Revert ( IStorage *  iface )

static

Definition at line 5514 of file storage32.c.

{
  FIXME("(%p): stub\n", iface);
  return S_OK;
}

StorageInternalImpl_SetTransactionSig()

static HRESULT StorageInternalImpl_SetTransactionSig ( StorageBaseImpl *  base, ULONG  value  )

static

Definition at line 5479 of file storage32.c.

{
  return E_NOTIMPL;
}

StorageInternalImpl_StreamLink()

static HRESULT StorageInternalImpl_StreamLink ( StorageBaseImpl *  base, DirRef  dst, DirRef  src  )

static

Definition at line 5464 of file storage32.c.

{
  StorageInternalImpl* This = (StorageInternalImpl*) base;
 
  return StorageBaseImpl_StreamLink(This->parentStorage,
    dst, src);
}

StorageInternalImpl_StreamReadAt()

static HRESULT StorageInternalImpl_StreamReadAt ( StorageBaseImpl *  base, DirRef  index, ULARGE_INTEGER  offset, ULONG  size, void *  buffer, ULONG *  bytesRead  )

static

Definition at line 5437 of file storage32.c.

{
  StorageInternalImpl* This = (StorageInternalImpl*) base;
 
  return StorageBaseImpl_StreamReadAt(This->parentStorage,
    index, offset, size, buffer, bytesRead);
}

StorageInternalImpl_StreamSetSize()

static HRESULT StorageInternalImpl_StreamSetSize ( StorageBaseImpl *  base, DirRef  index, ULARGE_INTEGER  newsize  )

static

Definition at line 5455 of file storage32.c.

{
  StorageInternalImpl* This = (StorageInternalImpl*) base;
 
  return StorageBaseImpl_StreamSetSize(This->parentStorage,
    index, newsize);
}

StorageInternalImpl_StreamWriteAt()

static HRESULT StorageInternalImpl_StreamWriteAt ( StorageBaseImpl *  base, DirRef  index, ULARGE_INTEGER  offset, ULONG  size, const void *  buffer, ULONG *  bytesWritten  )

static

Definition at line 5446 of file storage32.c.

{
  StorageInternalImpl* This = (StorageInternalImpl*) base;
 
  return StorageBaseImpl_StreamWriteAt(This->parentStorage,
    index, offset, size, buffer, bytesWritten);
}

StorageInternalImpl_UnlockTransaction()

static HRESULT StorageInternalImpl_UnlockTransaction ( StorageBaseImpl *  base, BOOL  write  )

static

Definition at line 5490 of file storage32.c.

{
  return E_NOTIMPL;
}

StorageInternalImpl_WriteDirEntry()

static HRESULT StorageInternalImpl_WriteDirEntry ( StorageBaseImpl *  base, DirRef  index, const DirEntry *  data  )

static

Definition at line 5410 of file storage32.c.

{
  StorageInternalImpl* This = (StorageInternalImpl*) base;
 
  return StorageBaseImpl_WriteDirEntry(This->parentStorage,
    index, data);
}

StorageUtl_CopyDirEntryToSTATSTG()

void StorageUtl_CopyDirEntryToSTATSTG	(	StorageBaseImpl *	storage,
		STATSTG *	destination,
		const DirEntry *	source,
		int	statFlags
	)

Definition at line 7017 of file storage32.c.

{
  /*
   * The copy of the string occurs only when the flag is not set
   */
  if (!(statFlags & STATFLAG_NONAME) && source->stgType == STGTY_ROOT)
  {
    /* Use the filename for the root storage. */
    destination->pwcsName = 0;
    StorageBaseImpl_GetFilename(storage, &destination->pwcsName);
  }
  else if( ((statFlags & STATFLAG_NONAME) != 0) ||
       (source->name[0] == 0) )
  {
    destination->pwcsName = 0;
  }
  else
  {
    destination->pwcsName =
      CoTaskMemAlloc((lstrlenW(source->name)+1)*sizeof(WCHAR));
 
    lstrcpyW(destination->pwcsName, source->name);
  }
 
  switch (source->stgType)
  {
    case STGTY_STORAGE:
    case STGTY_ROOT:
      destination->type = STGTY_STORAGE;
      break;
    case STGTY_STREAM:
      destination->type = STGTY_STREAM;
      break;
    default:
      destination->type = STGTY_STREAM;
      break;
  }
 
  destination->cbSize            = source->size;
/*
  currentReturnStruct->mtime     = {0}; TODO
  currentReturnStruct->ctime     = {0};
  currentReturnStruct->atime     = {0};
*/
  destination->grfMode           = 0;
  destination->grfLocksSupported = 0;
  destination->clsid             = source->clsid;
  destination->grfStateBits      = 0;
  destination->reserved          = 0;
}

Referenced by IEnumSTATSTGImpl_Next(), StgStreamImpl_Stat(), and StorageBaseImpl_Stat().

StorageUtl_ReadDWord()

void StorageUtl_ReadDWord	(	const BYTE *	buffer,
		ULONG	offset,
		DWORD *	value
	)

Definition at line 6957 of file storage32.c.

{
  DWORD tmp;
 
  memcpy(&tmp, buffer+offset, sizeof(DWORD));
  *value = lendian32toh(tmp);
}

Referenced by PropertyStorage_ReadDictionary(), PropertyStorage_ReadFmtIdOffsetFromStream(), PropertyStorage_ReadHeaderFromStream(), PropertyStorage_ReadProperty(), PropertyStorage_ReadSectionHeaderFromStream(), SmallBlockChainStream_GetNextBlockInChain(), SmallBlockChainStream_GetNextFreeBlock(), Storage32Impl_GetExtDepotBlock(), StorageImpl_GetNextBlockInChain(), StorageImpl_GetNextFreeBigBlock(), StorageImpl_GetTransactionSig(), StorageImpl_LoadFileHeader(), StorageImpl_ReadDirEntry(), and StorageUtl_ReadGUID().

StorageUtl_ReadGUID()

void StorageUtl_ReadGUID	(	const BYTE *	buffer,
		ULONG	offset,
		GUID *	value
	)

Definition at line 6999 of file storage32.c.

{
  StorageUtl_ReadDWord(buffer, offset,   &(value->Data1));
  StorageUtl_ReadWord(buffer,  offset+4, &(value->Data2));
  StorageUtl_ReadWord(buffer,  offset+6, &(value->Data3));
 
  memcpy(value->Data4, buffer+offset+8, sizeof(value->Data4));
}

Referenced by PropertyStorage_ReadFmtIdOffsetFromStream(), PropertyStorage_ReadHeaderFromStream(), and StorageImpl_ReadDirEntry().

StorageUtl_ReadULargeInteger()

void StorageUtl_ReadULargeInteger	(	const BYTE *	buffer,
		ULONG	offset,
		ULARGE_INTEGER *	value
	)

Definition at line 6971 of file storage32.c.

{
#ifdef WORDS_BIGENDIAN
    ULARGE_INTEGER tmp;
 
    memcpy(&tmp, buffer + offset, sizeof(ULARGE_INTEGER));
    value->u.LowPart = htole32(tmp.u.HighPart);
    value->u.HighPart = htole32(tmp.u.LowPart);
#else
    memcpy(value, buffer + offset, sizeof(ULARGE_INTEGER));
#endif
}

Referenced by PropertyStorage_ReadProperty().

StorageUtl_ReadWord()

void StorageUtl_ReadWord	(	const BYTE *	buffer,
		ULONG	offset,
		WORD *	value
	)

Definition at line 6943 of file storage32.c.

{
  WORD tmp;
 
  memcpy(&tmp, buffer+offset, sizeof(WORD));
  *value = lendian16toh(tmp);
}

Referenced by PropertyStorage_ReadHeaderFromStream(), PropertyStorage_ReadProperty(), StorageImpl_CreateDirEntry(), StorageImpl_LoadFileHeader(), StorageImpl_ReadDirEntry(), and StorageUtl_ReadGUID().

StorageUtl_WriteDWord()

void StorageUtl_WriteDWord	(	BYTE *	buffer,
		ULONG	offset,
		DWORD	value
	)

Definition at line 6965 of file storage32.c.

{
  value = htole32(value);
  memcpy(buffer+offset, &value, sizeof(DWORD));
}

Referenced by PropertyStorage_DictionaryWriter(), PropertyStorage_MakeFmtIdOffset(), PropertyStorage_MakeHeader(), PropertyStorage_MakePropertyIdOffset(), PropertyStorage_MakeSectionHdr(), PropertyStorage_WriteDictionaryToStream(), PropertyStorage_WritePropertyToStream(), PropertyStorage_WriteToStream(), SmallBlockChainStream_SetNextBlockInChain(), StorageImpl_Refresh(), StorageImpl_SaveFileHeader(), StorageUtl_WriteGUID(), and UpdateRawDirEntry().

StorageUtl_WriteGUID()

void StorageUtl_WriteGUID	(	BYTE *	buffer,
		ULONG	offset,
		const GUID *	value
	)

Definition at line 7008 of file storage32.c.

{
  StorageUtl_WriteDWord(buffer, offset,   value->Data1);
  StorageUtl_WriteWord(buffer,  offset+4, value->Data2);
  StorageUtl_WriteWord(buffer,  offset+6, value->Data3);
 
  memcpy(buffer+offset+8, value->Data4, sizeof(value->Data4));
}

Referenced by PropertyStorage_MakeFmtIdOffset(), PropertyStorage_MakeHeader(), PropertyStorage_WritePropertyToStream(), and UpdateRawDirEntry().

StorageUtl_WriteULargeInteger()

void StorageUtl_WriteULargeInteger	(	BYTE *	buffer,
		ULONG	offset,
		const ULARGE_INTEGER *	value
	)

Definition at line 6985 of file storage32.c.

{
#ifdef WORDS_BIGENDIAN
    ULARGE_INTEGER tmp;
 
    tmp.u.LowPart = htole32(value->u.HighPart);
    tmp.u.HighPart = htole32(value->u.LowPart);
    memcpy(buffer + offset, &tmp, sizeof(ULARGE_INTEGER));
#else
    memcpy(buffer + offset, value, sizeof(ULARGE_INTEGER));
#endif
}

Referenced by PropertyStorage_WritePropertyToStream().

StorageUtl_WriteWord()

void StorageUtl_WriteWord	(	BYTE *	buffer,
		ULONG	offset,
		WORD	value
	)

Definition at line 6951 of file storage32.c.

{
  value = htole16(value);
  memcpy(buffer+offset, &value, sizeof(WORD));
}

Referenced by PropertyStorage_MakeHeader(), PropertyStorage_WritePropertyToStream(), StorageImpl_SaveFileHeader(), StorageUtl_WriteGUID(), and UpdateRawDirEntry().

STREAM_ReadString()

static HRESULT STREAM_ReadString ( IStream *  stm, LPWSTR *  string  )

static

Definition at line 9261 of file storage32.c.

{
    HRESULT r;
    DWORD len, count = 0;
    LPSTR str;
    LPWSTR wstr;
 
    r = IStream_Read( stm, &len, sizeof(len), &count );
    if( FAILED( r ) )
        return r;
    if( count != sizeof(len) )
        return E_OUTOFMEMORY;
 
    TRACE("%d bytes\n",len);
 
    str = CoTaskMemAlloc( len );
    if( !str )
        return E_OUTOFMEMORY;
    count = 0;
    r = IStream_Read( stm, str, len, &count );
    if( FAILED( r ) )
    {
        CoTaskMemFree( str );
        return r;
    }
    if( count != len )
    {
        CoTaskMemFree( str );
        return E_OUTOFMEMORY;
    }
 
    TRACE("Read string %s\n",debugstr_an(str,len));
 
    len = MultiByteToWideChar( CP_ACP, 0, str, count, NULL, 0 );
    wstr = CoTaskMemAlloc( (len + 1)*sizeof (WCHAR) );
    if( wstr )
    {
         MultiByteToWideChar( CP_ACP, 0, str, count, wstr, len );
         wstr[len] = 0;
    }
    CoTaskMemFree( str );
 
    *string = wstr;
 
    return r;
}

Referenced by ReadFmtUserTypeStg().

STREAM_WriteString()

static HRESULT STREAM_WriteString ( IStream *  stm, LPCWSTR  string  )

static

Definition at line 9240 of file storage32.c.

{
    HRESULT r;
    LPSTR str;
    DWORD len = 0;
 
    if( string )
        len = WideCharToMultiByte( CP_ACP, 0, string, -1, NULL, 0, NULL, NULL);
    r = IStream_Write( stm, &len, sizeof(len), NULL);
    if( FAILED( r ) )
        return r;
    if(len == 0)
        return r;
    str = CoTaskMemAlloc( len );
    WideCharToMultiByte( CP_ACP, 0, string, -1, str, len, NULL, NULL);
    r = IStream_Write( stm, str, len, NULL);
    CoTaskMemFree( str );
    return r;
}

Referenced by STORAGE_WriteCompObj().

TransactedSharedImpl_Commit()

static HRESULT WINAPI TransactedSharedImpl_Commit ( IStorage *  iface, DWORD  grfCommitFlags  )

static

Definition at line 6675 of file storage32.c.

{
  TransactedSharedImpl* This = (TransactedSharedImpl*)impl_from_IStorage(iface);
  DirRef new_storage_ref, prev_storage_ref;
  DirEntry src_data, dst_data;
  HRESULT hr;
  ULONG transactionSig;
 
  TRACE("(%p,%x)\n", iface, grfCommitFlags);
 
  /* Cannot commit a read-only transacted storage */
  if ( STGM_ACCESS_MODE( This->base.openFlags ) == STGM_READ )
    return STG_E_ACCESSDENIED;
 
  hr = StorageBaseImpl_LockTransaction(This->transactedParent, TRUE);
  if (hr == E_NOTIMPL) hr = S_OK;
  if (SUCCEEDED(hr))
  {
    hr = StorageBaseImpl_GetTransactionSig(This->transactedParent, &transactionSig, TRUE);
    if (SUCCEEDED(hr))
    {
      if ((grfCommitFlags & STGC_ONLYIFCURRENT) && transactionSig != This->lastTransactionSig)
        hr = STG_E_NOTCURRENT;
 
      if (SUCCEEDED(hr))
        hr = StorageBaseImpl_SetTransactionSig(This->transactedParent, transactionSig+1);
    }
    else if (hr == E_NOTIMPL)
      hr = S_OK;
 
    if (SUCCEEDED(hr))
      hr = StorageBaseImpl_ReadDirEntry(&This->scratch->base, This->scratch->base.storageDirEntry, &src_data);
 
    /* FIXME: If we're current, we should be able to copy only the changes in scratch. */
    if (SUCCEEDED(hr))
      hr = StorageBaseImpl_DupStorageTree(This->transactedParent, &new_storage_ref, &This->scratch->base, src_data.dirRootEntry);
 
    if (SUCCEEDED(hr))
      hr = StorageBaseImpl_Flush(This->transactedParent);
 
    if (SUCCEEDED(hr))
      hr = StorageBaseImpl_ReadDirEntry(This->transactedParent, This->transactedParent->storageDirEntry, &dst_data);
 
    if (SUCCEEDED(hr))
    {
      prev_storage_ref = dst_data.dirRootEntry;
      dst_data.dirRootEntry = new_storage_ref;
      dst_data.clsid = src_data.clsid;
      dst_data.ctime = src_data.ctime;
      dst_data.mtime = src_data.mtime;
      hr = StorageBaseImpl_WriteDirEntry(This->transactedParent, This->transactedParent->storageDirEntry, &dst_data);
    }
 
    if (SUCCEEDED(hr))
    {
      /* Try to flush after updating the root storage, but if the flush fails, keep
       * going, on the theory that it'll either succeed later or the subsequent
       * writes will fail. */
      StorageBaseImpl_Flush(This->transactedParent);
 
      hr = StorageBaseImpl_DeleteStorageTree(This->transactedParent, prev_storage_ref, TRUE);
    }
 
    if (SUCCEEDED(hr))
      hr = StorageBaseImpl_Flush(This->transactedParent);
 
    StorageBaseImpl_UnlockTransaction(This->transactedParent, TRUE);
 
    if (SUCCEEDED(hr))
      hr = IStorage_Commit(&This->scratch->base.IStorage_iface, STGC_DEFAULT);
 
    if (SUCCEEDED(hr))
    {
      This->lastTransactionSig = transactionSig+1;
    }
  }
  TRACE("<-- %08x\n", hr);
  return hr;
}

TransactedSharedImpl_Construct()

static HRESULT TransactedSharedImpl_Construct ( StorageBaseImpl *  parentStorage, TransactedSharedImpl **  result  )

static

Definition at line 6812 of file storage32.c.

{
  HRESULT hr;
 
  *result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(TransactedSharedImpl));
  if (*result)
  {
    IStorage *scratch;
 
    (*result)->base.IStorage_iface.lpVtbl = &TransactedSharedImpl_Vtbl;
 
    /* This is OK because the property set storage functions use the IStorage functions. */
    (*result)->base.IPropertySetStorage_iface.lpVtbl = parentStorage->IPropertySetStorage_iface.lpVtbl;
    (*result)->base.baseVtbl = &TransactedSharedImpl_BaseVtbl;
 
    list_init(&(*result)->base.strmHead);
 
    list_init(&(*result)->base.storageHead);
 
    (*result)->base.ref = 1;
 
    (*result)->base.openFlags = parentStorage->openFlags;
 
    hr = StorageBaseImpl_LockTransaction(parentStorage, FALSE);
 
    if (SUCCEEDED(hr))
    {
      STGOPTIONS stgo;
 
      /* This cannot fail, except with E_NOTIMPL in which case we don't care */
      StorageBaseImpl_GetTransactionSig(parentStorage, &(*result)->lastTransactionSig, FALSE);
 
      stgo.usVersion = 1;
      stgo.reserved = 0;
      stgo.ulSectorSize = 4096;
      stgo.pwcsTemplateFile = NULL;
 
      /* Create a new temporary storage to act as the scratch file. */
      hr = StgCreateStorageEx(NULL, STGM_READWRITE|STGM_SHARE_EXCLUSIVE|STGM_CREATE|STGM_DELETEONRELEASE|STGM_TRANSACTED,
          STGFMT_DOCFILE, 0, &stgo, NULL, &IID_IStorage, (void**)&scratch);
      (*result)->scratch = (TransactedSnapshotImpl*)impl_from_IStorage(scratch);
 
      if (SUCCEEDED(hr))
      {
        hr = StorageBaseImpl_CopyStorageTree(&(*result)->scratch->base, (*result)->scratch->base.storageDirEntry,
          parentStorage, parentStorage->storageDirEntry);
 
        if (SUCCEEDED(hr))
        {
          hr = IStorage_Commit(scratch, STGC_DEFAULT);
 
          (*result)->base.storageDirEntry = (*result)->scratch->base.storageDirEntry;
          (*result)->transactedParent = parentStorage;
        }
 
        if (FAILED(hr))
          IStorage_Release(scratch);
      }
 
      StorageBaseImpl_UnlockTransaction(parentStorage, FALSE);
    }
 
    if (FAILED(hr)) HeapFree(GetProcessHeap(), 0, *result);
 
    return hr;
  }
  else
    return E_OUTOFMEMORY;
}

Referenced by Storage_ConstructTransacted().

TransactedSharedImpl_CreateDirEntry()

static HRESULT TransactedSharedImpl_CreateDirEntry ( StorageBaseImpl *  base, const DirEntry *  newData, DirRef *  index  )

static

Definition at line 6581 of file storage32.c.

{
  TransactedSharedImpl* This = (TransactedSharedImpl*) base;
 
  return StorageBaseImpl_CreateDirEntry(&This->scratch->base,
    newData, index);
}

TransactedSharedImpl_Destroy()

static void TransactedSharedImpl_Destroy ( StorageBaseImpl *  iface )

static

Definition at line 6558 of file storage32.c.

{
  TransactedSharedImpl* This = (TransactedSharedImpl*) iface;
 
  TransactedSharedImpl_Invalidate(&This->base);
  IStorage_Release(&This->transactedParent->IStorage_iface);
  IStorage_Release(&This->scratch->base.IStorage_iface);
  HeapFree(GetProcessHeap(), 0, This);
}

TransactedSharedImpl_DestroyDirEntry()

static HRESULT TransactedSharedImpl_DestroyDirEntry ( StorageBaseImpl *  base, DirRef  index  )

static

Definition at line 6608 of file storage32.c.

{
  TransactedSharedImpl* This = (TransactedSharedImpl*) base;
 
  return StorageBaseImpl_DestroyDirEntry(&This->scratch->base,
    index);
}

TransactedSharedImpl_Flush()

static HRESULT TransactedSharedImpl_Flush ( StorageBaseImpl *  iface )

static

Definition at line 6568 of file storage32.c.

{
  /* We only need to flush when committing. */
  return S_OK;
}

TransactedSharedImpl_GetFilename()

static HRESULT TransactedSharedImpl_GetFilename ( StorageBaseImpl *  iface, LPWSTR *  result  )

static

Definition at line 6574 of file storage32.c.

{
  TransactedSharedImpl* This = (TransactedSharedImpl*) iface;
 
  return StorageBaseImpl_GetFilename(This->transactedParent, result);
}

TransactedSharedImpl_GetTransactionSig()

static HRESULT TransactedSharedImpl_GetTransactionSig ( StorageBaseImpl *  base, ULONG *  result, BOOL  refresh  )

static

Definition at line 6653 of file storage32.c.

{
  return E_NOTIMPL;
}

TransactedSharedImpl_Invalidate()

static void TransactedSharedImpl_Invalidate ( StorageBaseImpl *  This )

static

Definition at line 6546 of file storage32.c.

{
  if (!This->reverted)
  {
    TRACE("Storage invalidated (stg=%p)\n", This);
 
    This->reverted = TRUE;
 
    StorageBaseImpl_DeleteAll(This);
  }
}

Referenced by TransactedSharedImpl_Destroy().

TransactedSharedImpl_LockTransaction()

static HRESULT TransactedSharedImpl_LockTransaction ( StorageBaseImpl *  base, BOOL  write  )

static

Definition at line 6665 of file storage32.c.

{
  return E_NOTIMPL;
}

TransactedSharedImpl_ReadDirEntry()

static HRESULT TransactedSharedImpl_ReadDirEntry ( StorageBaseImpl *  base, DirRef  index, DirEntry *  data  )

static

Definition at line 6599 of file storage32.c.

{
  TransactedSharedImpl* This = (TransactedSharedImpl*) base;
 
  return StorageBaseImpl_ReadDirEntry(&This->scratch->base,
    index, data);
}

TransactedSharedImpl_Revert()

static HRESULT WINAPI TransactedSharedImpl_Revert ( IStorage *  iface )

static

Definition at line 6757 of file storage32.c.

{
  TransactedSharedImpl* This = (TransactedSharedImpl*)impl_from_IStorage(iface);
 
  TRACE("(%p)\n", iface);
 
  /* Destroy the open objects. */
  StorageBaseImpl_DeleteAll(&This->base);
 
  return IStorage_Revert(&This->scratch->base.IStorage_iface);
}

TransactedSharedImpl_SetTransactionSig()

static HRESULT TransactedSharedImpl_SetTransactionSig ( StorageBaseImpl *  base, ULONG  value  )

static

Definition at line 6659 of file storage32.c.

{
  return E_NOTIMPL;
}

TransactedSharedImpl_StreamLink()

static HRESULT TransactedSharedImpl_StreamLink ( StorageBaseImpl *  base, DirRef  dst, DirRef  src  )

static

Definition at line 6644 of file storage32.c.

{
  TransactedSharedImpl* This = (TransactedSharedImpl*) base;
 
  return StorageBaseImpl_StreamLink(&This->scratch->base,
    dst, src);
}

TransactedSharedImpl_StreamReadAt()

static HRESULT TransactedSharedImpl_StreamReadAt ( StorageBaseImpl *  base, DirRef  index, ULARGE_INTEGER  offset, ULONG  size, void *  buffer, ULONG *  bytesRead  )

static

Definition at line 6617 of file storage32.c.

{
  TransactedSharedImpl* This = (TransactedSharedImpl*) base;
 
  return StorageBaseImpl_StreamReadAt(&This->scratch->base,
    index, offset, size, buffer, bytesRead);
}

TransactedSharedImpl_StreamSetSize()

static HRESULT TransactedSharedImpl_StreamSetSize ( StorageBaseImpl *  base, DirRef  index, ULARGE_INTEGER  newsize  )

static

Definition at line 6635 of file storage32.c.

{
  TransactedSharedImpl* This = (TransactedSharedImpl*) base;
 
  return StorageBaseImpl_StreamSetSize(&This->scratch->base,
    index, newsize);
}

TransactedSharedImpl_StreamWriteAt()

static HRESULT TransactedSharedImpl_StreamWriteAt ( StorageBaseImpl *  base, DirRef  index, ULARGE_INTEGER  offset, ULONG  size, const void *  buffer, ULONG *  bytesWritten  )

static

Definition at line 6626 of file storage32.c.

{
  TransactedSharedImpl* This = (TransactedSharedImpl*) base;
 
  return StorageBaseImpl_StreamWriteAt(&This->scratch->base,
    index, offset, size, buffer, bytesWritten);
}

TransactedSharedImpl_UnlockTransaction()

static HRESULT TransactedSharedImpl_UnlockTransaction ( StorageBaseImpl *  base, BOOL  write  )

static

Definition at line 6670 of file storage32.c.

{
  return E_NOTIMPL;
}

TransactedSharedImpl_WriteDirEntry()

static HRESULT TransactedSharedImpl_WriteDirEntry ( StorageBaseImpl *  base, DirRef  index, const DirEntry *  data  )

static

Definition at line 6590 of file storage32.c.

{
  TransactedSharedImpl* This = (TransactedSharedImpl*) base;
 
  return StorageBaseImpl_WriteDirEntry(&This->scratch->base,
    index, data);
}

TransactedSnapshotImpl_Commit()

static HRESULT WINAPI TransactedSnapshotImpl_Commit ( IStorage *  iface, DWORD  grfCommitFlags  )

static

Definition at line 5957 of file storage32.c.

{
  TransactedSnapshotImpl* This = (TransactedSnapshotImpl*)impl_from_IStorage(iface);
  TransactedDirEntry *root_entry;
  DirRef i, dir_root_ref;
  DirEntry data;
  ULARGE_INTEGER zero;
  HRESULT hr;
  ULONG transactionSig;
 
  zero.QuadPart = 0;
 
  TRACE("(%p,%x)\n", iface, grfCommitFlags);
 
  /* Cannot commit a read-only transacted storage */
  if ( STGM_ACCESS_MODE( This->base.openFlags ) == STGM_READ )
    return STG_E_ACCESSDENIED;
 
  hr = StorageBaseImpl_LockTransaction(This->transactedParent, TRUE);
  if (hr == E_NOTIMPL) hr = S_OK;
  if (SUCCEEDED(hr))
  {
    hr = StorageBaseImpl_GetTransactionSig(This->transactedParent, &transactionSig, TRUE);
    if (SUCCEEDED(hr))
    {
      if (transactionSig != This->lastTransactionSig)
      {
        ERR("file was externally modified\n");
        hr = STG_E_NOTCURRENT;
      }
 
      if (SUCCEEDED(hr))
      {
        This->lastTransactionSig = transactionSig+1;
        hr = StorageBaseImpl_SetTransactionSig(This->transactedParent, This->lastTransactionSig);
      }
    }
    else if (hr == E_NOTIMPL)
      hr = S_OK;
 
    if (FAILED(hr)) goto end;
 
    /* To prevent data loss, we create the new structure in the file before we
     * delete the old one, so that in case of errors the old data is intact. We
     * shouldn't do this if STGC_OVERWRITE is set, but that flag should only be
     * needed in the rare situation where we have just enough free disk space to
     * overwrite the existing data. */
 
    root_entry = &This->entries[This->base.storageDirEntry];
 
    if (!root_entry->read)
      goto end;
 
    hr = TransactedSnapshotImpl_CopyTree(This);
    if (FAILED(hr)) goto end;
 
    if (root_entry->data.dirRootEntry == DIRENTRY_NULL)
      dir_root_ref = DIRENTRY_NULL;
    else
      dir_root_ref = This->entries[root_entry->data.dirRootEntry].newTransactedParentEntry;
 
    hr = StorageBaseImpl_Flush(This->transactedParent);
 
    /* Update the storage to use the new data in one step. */
    if (SUCCEEDED(hr))
      hr = StorageBaseImpl_ReadDirEntry(This->transactedParent,
        root_entry->transactedParentEntry, &data);
 
    if (SUCCEEDED(hr))
    {
      data.dirRootEntry = dir_root_ref;
      data.clsid = root_entry->data.clsid;
      data.ctime = root_entry->data.ctime;
      data.mtime = root_entry->data.mtime;
 
      hr = StorageBaseImpl_WriteDirEntry(This->transactedParent,
        root_entry->transactedParentEntry, &data);
    }
 
    /* Try to flush after updating the root storage, but if the flush fails, keep
     * going, on the theory that it'll either succeed later or the subsequent
     * writes will fail. */
    StorageBaseImpl_Flush(This->transactedParent);
 
    if (SUCCEEDED(hr))
    {
      /* Destroy the old now-orphaned data. */
      for (i=0; i<This->entries_size; i++)
      {
        TransactedDirEntry *entry = &This->entries[i];
        if (entry->inuse)
        {
          if (entry->deleted)
          {
            StorageBaseImpl_StreamSetSize(This->transactedParent,
              entry->transactedParentEntry, zero);
            StorageBaseImpl_DestroyDirEntry(This->transactedParent,
              entry->transactedParentEntry);
            memset(entry, 0, sizeof(TransactedDirEntry));
            This->firstFreeEntry = min(i, This->firstFreeEntry);
          }
          else if (entry->read && entry->transactedParentEntry != entry->newTransactedParentEntry)
          {
            if (entry->transactedParentEntry != DIRENTRY_NULL)
              StorageBaseImpl_DestroyDirEntry(This->transactedParent,
                entry->transactedParentEntry);
            if (entry->stream_dirty)
            {
              StorageBaseImpl_StreamSetSize(This->scratch, entry->stream_entry, zero);
              StorageBaseImpl_DestroyDirEntry(This->scratch, entry->stream_entry);
              entry->stream_dirty = FALSE;
            }
            entry->dirty = FALSE;
            entry->transactedParentEntry = entry->newTransactedParentEntry;
          }
        }
      }
    }
    else
    {
      TransactedSnapshotImpl_DestroyTemporaryCopy(This, DIRENTRY_NULL);
    }
 
    if (SUCCEEDED(hr))
      hr = StorageBaseImpl_Flush(This->transactedParent);
end:
    StorageBaseImpl_UnlockTransaction(This->transactedParent, TRUE);
  }
 
  TRACE("<-- %08x\n", hr);
  return hr;
}

TransactedSnapshotImpl_Construct()

static HRESULT TransactedSnapshotImpl_Construct ( StorageBaseImpl *  parentStorage, TransactedSnapshotImpl **  result  )

static

Definition at line 6476 of file storage32.c.

{
  HRESULT hr;
 
  *result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(TransactedSnapshotImpl));
  if (*result)
  {
    IStorage *scratch;
 
    (*result)->base.IStorage_iface.lpVtbl = &TransactedSnapshotImpl_Vtbl;
 
    /* This is OK because the property set storage functions use the IStorage functions. */
    (*result)->base.IPropertySetStorage_iface.lpVtbl = parentStorage->IPropertySetStorage_iface.lpVtbl;
    (*result)->base.baseVtbl = &TransactedSnapshotImpl_BaseVtbl;
 
    list_init(&(*result)->base.strmHead);
 
    list_init(&(*result)->base.storageHead);
 
    (*result)->base.ref = 1;
 
    (*result)->base.openFlags = parentStorage->openFlags;
 
    /* This cannot fail, except with E_NOTIMPL in which case we don't care */
    StorageBaseImpl_GetTransactionSig(parentStorage, &(*result)->lastTransactionSig, FALSE);
 
    /* Create a new temporary storage to act as the scratch file. */
    hr = StgCreateDocfile(NULL, STGM_READWRITE|STGM_SHARE_EXCLUSIVE|STGM_CREATE|STGM_DELETEONRELEASE,
        0, &scratch);
    (*result)->scratch = impl_from_IStorage(scratch);
 
    if (SUCCEEDED(hr))
    {
        ULONG num_entries = 20;
 
        (*result)->entries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(TransactedDirEntry) * num_entries);
        (*result)->entries_size = num_entries;
        (*result)->firstFreeEntry = 0;
 
        if ((*result)->entries)
        {
            /* parentStorage already has 1 reference, which we take over here. */
            (*result)->transactedParent = parentStorage;
 
            parentStorage->transactedChild = &(*result)->base;
 
            (*result)->base.storageDirEntry = TransactedSnapshotImpl_CreateStubEntry(*result, parentStorage->storageDirEntry);
        }
        else
        {
            IStorage_Release(scratch);
 
            hr = E_OUTOFMEMORY;
        }
    }
 
    if (FAILED(hr)) HeapFree(GetProcessHeap(), 0, *result);
 
    return hr;
  }
  else
    return E_OUTOFMEMORY;
}

Referenced by Storage_ConstructTransacted().

TransactedSnapshotImpl_CopyTree()

static HRESULT TransactedSnapshotImpl_CopyTree ( TransactedSnapshotImpl *  This )

static

Definition at line 5875 of file storage32.c.

{
  DirRef cursor;
  TransactedDirEntry *entry;
  HRESULT hr = S_OK;
 
  cursor = This->base.storageDirEntry;
  entry = &This->entries[cursor];
  entry->parent = DIRENTRY_NULL;
  entry->newTransactedParentEntry = entry->transactedParentEntry;
 
  if (entry->data.dirRootEntry == DIRENTRY_NULL)
    return S_OK;
 
  This->entries[entry->data.dirRootEntry].parent = DIRENTRY_NULL;
 
  cursor = TransactedSnapshotImpl_FindFirstChild(This, entry->data.dirRootEntry);
  entry = &This->entries[cursor];
 
  while (cursor != DIRENTRY_NULL)
  {
    /* Make a copy of this entry in the transacted parent. */
    if (!entry->read ||
        (!entry->dirty && !entry->stream_dirty &&
         !TransactedSnapshotImpl_MadeCopy(This, entry->data.leftChild) &&
         !TransactedSnapshotImpl_MadeCopy(This, entry->data.rightChild) &&
         !TransactedSnapshotImpl_MadeCopy(This, entry->data.dirRootEntry)))
      entry->newTransactedParentEntry = entry->transactedParentEntry;
    else
    {
      DirEntry newData;
 
      memcpy(&newData, &entry->data, sizeof(DirEntry));
 
      newData.size.QuadPart = 0;
      newData.startingBlock = BLOCK_END_OF_CHAIN;
 
      if (newData.leftChild != DIRENTRY_NULL)
        newData.leftChild = This->entries[newData.leftChild].newTransactedParentEntry;
 
      if (newData.rightChild != DIRENTRY_NULL)
        newData.rightChild = This->entries[newData.rightChild].newTransactedParentEntry;
 
      if (newData.dirRootEntry != DIRENTRY_NULL)
        newData.dirRootEntry = This->entries[newData.dirRootEntry].newTransactedParentEntry;
 
      hr = StorageBaseImpl_CreateDirEntry(This->transactedParent, &newData,
        &entry->newTransactedParentEntry);
      if (FAILED(hr))
      {
        TransactedSnapshotImpl_DestroyTemporaryCopy(This, cursor);
        return hr;
      }
 
      if (entry->stream_dirty)
      {
        hr = StorageBaseImpl_CopyStream(
          This->transactedParent, entry->newTransactedParentEntry,
          This->scratch, entry->stream_entry);
      }
      else if (entry->data.size.QuadPart)
      {
        hr = StorageBaseImpl_StreamLink(
          This->transactedParent, entry->newTransactedParentEntry,
          entry->transactedParentEntry);
      }
 
      if (FAILED(hr))
      {
        cursor = TransactedSnapshotImpl_FindNextChild(This, cursor);
        TransactedSnapshotImpl_DestroyTemporaryCopy(This, cursor);
        return hr;
      }
    }
 
    cursor = TransactedSnapshotImpl_FindNextChild(This, cursor);
    entry = &This->entries[cursor];
  }
 
  return hr;
}

Referenced by TransactedSnapshotImpl_Commit().

TransactedSnapshotImpl_CreateDirEntry()

static HRESULT TransactedSnapshotImpl_CreateDirEntry ( StorageBaseImpl *  base, const DirEntry *  newData, DirRef *  index  )

static

Definition at line 6161 of file storage32.c.

{
  TransactedSnapshotImpl* This = (TransactedSnapshotImpl*) base;
  DirRef new_ref;
  TransactedDirEntry *new_entry;
 
  new_ref = TransactedSnapshotImpl_FindFreeEntry(This);
  if (new_ref == DIRENTRY_NULL)
    return E_OUTOFMEMORY;
 
  new_entry = &This->entries[new_ref];
 
  new_entry->newTransactedParentEntry = new_entry->transactedParentEntry = DIRENTRY_NULL;
  new_entry->read = TRUE;
  new_entry->dirty = TRUE;
  memcpy(&new_entry->data, newData, sizeof(DirEntry));
 
  *index = new_ref;
 
  TRACE("%s l=%x r=%x d=%x <-- %x\n", debugstr_w(newData->name), newData->leftChild, newData->rightChild, newData->dirRootEntry, *index);
 
  return S_OK;
}

TransactedSnapshotImpl_CreateStubEntry()

static DirRef TransactedSnapshotImpl_CreateStubEntry ( TransactedSnapshotImpl *  This, DirRef  parentEntryRef  )

static

Definition at line 5642 of file storage32.c.

{
  DirRef stubEntryRef;
  TransactedDirEntry *entry;
 
  stubEntryRef = TransactedSnapshotImpl_FindFreeEntry(This);
 
  if (stubEntryRef != DIRENTRY_NULL)
  {
    entry = &This->entries[stubEntryRef];
 
    entry->newTransactedParentEntry = entry->transactedParentEntry = parentEntryRef;
 
    entry->read = FALSE;
  }
 
  return stubEntryRef;
}

Referenced by TransactedSnapshotImpl_Construct(), TransactedSnapshotImpl_EnsureReadEntry(), TransactedSnapshotImpl_MakeStreamDirty(), TransactedSnapshotImpl_Revert(), TransactedSnapshotImpl_StreamSetSize(), and TransactedSnapshotImpl_WriteDirEntry().

TransactedSnapshotImpl_Destroy()

static void TransactedSnapshotImpl_Destroy ( StorageBaseImpl *  iface )

static

Definition at line 6137 of file storage32.c.

{
  TransactedSnapshotImpl* This = (TransactedSnapshotImpl*) iface;
 
  IStorage_Revert(&This->base.IStorage_iface);
  IStorage_Release(&This->transactedParent->IStorage_iface);
  IStorage_Release(&This->scratch->IStorage_iface);
  HeapFree(GetProcessHeap(), 0, This->entries);
  HeapFree(GetProcessHeap(), 0, This);
}

TransactedSnapshotImpl_DestroyDirEntry()

static HRESULT TransactedSnapshotImpl_DestroyDirEntry ( StorageBaseImpl *  base, DirRef  index  )

static

Definition at line 6245 of file storage32.c.

{
  TransactedSnapshotImpl* This = (TransactedSnapshotImpl*) base;
 
  if (This->entries[index].transactedParentEntry == DIRENTRY_NULL ||
      This->entries[index].data.size.QuadPart != 0)
  {
    /* If we deleted this entry while it has stream data. We must have left the
     * data because some other entry is using it, and we need to leave the
     * original entry alone. */
    memset(&This->entries[index], 0, sizeof(TransactedDirEntry));
    This->firstFreeEntry = min(index, This->firstFreeEntry);
  }
  else
  {
    This->entries[index].deleted = TRUE;
  }
 
  return S_OK;
}

TransactedSnapshotImpl_DestroyTemporaryCopy()

static void TransactedSnapshotImpl_DestroyTemporaryCopy ( TransactedSnapshotImpl *  This, DirRef  stop  )

static

Definition at line 5835 of file storage32.c.

{
  DirRef cursor;
  TransactedDirEntry *entry;
  ULARGE_INTEGER zero;
 
  zero.QuadPart = 0;
 
  if (!This->entries[This->base.storageDirEntry].read)
    return;
 
  cursor = This->entries[This->base.storageDirEntry].data.dirRootEntry;
 
  if (cursor == DIRENTRY_NULL)
    return;
 
  cursor = TransactedSnapshotImpl_FindFirstChild(This, cursor);
 
  while (cursor != DIRENTRY_NULL && cursor != stop)
  {
    if (TransactedSnapshotImpl_MadeCopy(This, cursor))
    {
      entry = &This->entries[cursor];
 
      if (entry->stream_dirty)
        StorageBaseImpl_StreamSetSize(This->transactedParent,
          entry->newTransactedParentEntry, zero);
 
      StorageBaseImpl_DestroyDirEntry(This->transactedParent,
        entry->newTransactedParentEntry);
 
      entry->newTransactedParentEntry = entry->transactedParentEntry;
    }
 
    cursor = TransactedSnapshotImpl_FindNextChild(This, cursor);
  }
}

Referenced by TransactedSnapshotImpl_Commit(), and TransactedSnapshotImpl_CopyTree().

TransactedSnapshotImpl_EnsureReadEntry()

static HRESULT TransactedSnapshotImpl_EnsureReadEntry ( TransactedSnapshotImpl *  This, DirRef  entry  )

static

Definition at line 5662 of file storage32.c.

{
  HRESULT hr=S_OK;
  DirEntry data;
 
  if (!This->entries[entry].read)
  {
    hr = StorageBaseImpl_ReadDirEntry(This->transactedParent,
        This->entries[entry].transactedParentEntry,
        &data);
 
    if (SUCCEEDED(hr) && data.leftChild != DIRENTRY_NULL)
    {
      data.leftChild = TransactedSnapshotImpl_CreateStubEntry(This, data.leftChild);
 
      if (data.leftChild == DIRENTRY_NULL)
        hr = E_OUTOFMEMORY;
    }
 
    if (SUCCEEDED(hr) && data.rightChild != DIRENTRY_NULL)
    {
      data.rightChild = TransactedSnapshotImpl_CreateStubEntry(This, data.rightChild);
 
      if (data.rightChild == DIRENTRY_NULL)
        hr = E_OUTOFMEMORY;
    }
 
    if (SUCCEEDED(hr) && data.dirRootEntry != DIRENTRY_NULL)
    {
      data.dirRootEntry = TransactedSnapshotImpl_CreateStubEntry(This, data.dirRootEntry);
 
      if (data.dirRootEntry == DIRENTRY_NULL)
        hr = E_OUTOFMEMORY;
    }
 
    if (SUCCEEDED(hr))
    {
      memcpy(&This->entries[entry].data, &data, sizeof(DirEntry));
      This->entries[entry].read = TRUE;
    }
  }
 
  return hr;
}

Referenced by TransactedSnapshotImpl_ReadDirEntry(), TransactedSnapshotImpl_StreamLink(), TransactedSnapshotImpl_StreamSetSize(), TransactedSnapshotImpl_StreamWriteAt(), and TransactedSnapshotImpl_WriteDirEntry().

TransactedSnapshotImpl_FindFirstChild()

static DirRef TransactedSnapshotImpl_FindFirstChild ( TransactedSnapshotImpl *  This, DirRef  parent  )

static

Definition at line 5760 of file storage32.c.

{
  DirRef cursor, prev;
  TransactedDirEntry *entry;
 
  cursor = parent;
  entry = &This->entries[cursor];
  while (entry->read)
  {
    if (entry->data.leftChild != DIRENTRY_NULL)
    {
      prev = cursor;
      cursor = entry->data.leftChild;
      entry = &This->entries[cursor];
      entry->parent = prev;
    }
    else if (entry->data.rightChild != DIRENTRY_NULL)
    {
      prev = cursor;
      cursor = entry->data.rightChild;
      entry = &This->entries[cursor];
      entry->parent = prev;
    }
    else if (entry->data.dirRootEntry != DIRENTRY_NULL)
    {
      prev = cursor;
      cursor = entry->data.dirRootEntry;
      entry = &This->entries[cursor];
      entry->parent = prev;
    }
    else
      break;
  }
 
  return cursor;
}

Referenced by TransactedSnapshotImpl_CopyTree(), TransactedSnapshotImpl_DestroyTemporaryCopy(), and TransactedSnapshotImpl_FindNextChild().

TransactedSnapshotImpl_FindFreeEntry()

static DirRef TransactedSnapshotImpl_FindFreeEntry ( TransactedSnapshotImpl *  This )

static

Definition at line 5613 of file storage32.c.

{
  DirRef result=This->firstFreeEntry;
 
  while (result < This->entries_size && This->entries[result].inuse)
    result++;
 
  if (result == This->entries_size)
  {
    ULONG new_size = This->entries_size * 2;
    TransactedDirEntry *new_entries;
 
    new_entries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(TransactedDirEntry) * new_size);
    if (!new_entries) return DIRENTRY_NULL;
 
    memcpy(new_entries, This->entries, sizeof(TransactedDirEntry) * This->entries_size);
    HeapFree(GetProcessHeap(), 0, This->entries);
 
    This->entries = new_entries;
    This->entries_size = new_size;
  }
 
  This->entries[result].inuse = TRUE;
 
  This->firstFreeEntry = result+1;
 
  return result;
}

Referenced by TransactedSnapshotImpl_CreateDirEntry(), and TransactedSnapshotImpl_CreateStubEntry().

TransactedSnapshotImpl_FindNextChild()

static DirRef TransactedSnapshotImpl_FindNextChild ( TransactedSnapshotImpl *  This, DirRef  current  )

static

Definition at line 5799 of file storage32.c.

{
  DirRef parent;
  TransactedDirEntry *parent_entry;
 
  parent = This->entries[current].parent;
  parent_entry = &This->entries[parent];
 
  if (parent != DIRENTRY_NULL && parent_entry->data.dirRootEntry != current)
  {
    if (parent_entry->data.rightChild != current && parent_entry->data.rightChild != DIRENTRY_NULL)
    {
      This->entries[parent_entry->data.rightChild].parent = parent;
      return TransactedSnapshotImpl_FindFirstChild(This, parent_entry->data.rightChild);
    }
 
    if (parent_entry->data.dirRootEntry != DIRENTRY_NULL)
    {
      This->entries[parent_entry->data.dirRootEntry].parent = parent;
      return TransactedSnapshotImpl_FindFirstChild(This, parent_entry->data.dirRootEntry);
    }
  }
 
  return parent;
}

Referenced by TransactedSnapshotImpl_CopyTree(), and TransactedSnapshotImpl_DestroyTemporaryCopy().

TransactedSnapshotImpl_Flush()

static HRESULT TransactedSnapshotImpl_Flush ( StorageBaseImpl *  iface )

static

Definition at line 6148 of file storage32.c.

{
  /* We only need to flush when committing. */
  return S_OK;
}

TransactedSnapshotImpl_GetFilename()

static HRESULT TransactedSnapshotImpl_GetFilename ( StorageBaseImpl *  iface, LPWSTR *  result  )

static

Definition at line 6154 of file storage32.c.

{
  TransactedSnapshotImpl* This = (TransactedSnapshotImpl*) iface;
 
  return StorageBaseImpl_GetFilename(This->transactedParent, result);
}

TransactedSnapshotImpl_GetTransactionSig()

static HRESULT TransactedSnapshotImpl_GetTransactionSig ( StorageBaseImpl *  base, ULONG *  result, BOOL  refresh  )

static

Definition at line 6412 of file storage32.c.

{
  return E_NOTIMPL;
}

TransactedSnapshotImpl_Invalidate()

static void TransactedSnapshotImpl_Invalidate ( StorageBaseImpl *  This )

static

Definition at line 6125 of file storage32.c.

{
  if (!This->reverted)
  {
    TRACE("Storage invalidated (stg=%p)\n", This);
 
    This->reverted = TRUE;
 
    StorageBaseImpl_DeleteAll(This);
  }
}

TransactedSnapshotImpl_LockTransaction()

static HRESULT TransactedSnapshotImpl_LockTransaction ( StorageBaseImpl *  base, BOOL  write  )

static

Definition at line 6424 of file storage32.c.

{
  return E_NOTIMPL;
}

TransactedSnapshotImpl_MadeCopy()

static BOOL TransactedSnapshotImpl_MadeCopy ( TransactedSnapshotImpl *  This, DirRef  entry  )

inlinestatic

Definition at line 5827 of file storage32.c.

{
  return entry != DIRENTRY_NULL &&
    This->entries[entry].newTransactedParentEntry != This->entries[entry].transactedParentEntry;
}

Referenced by TransactedSnapshotImpl_CopyTree(), and TransactedSnapshotImpl_DestroyTemporaryCopy().

TransactedSnapshotImpl_MakeStreamDirty()

static HRESULT TransactedSnapshotImpl_MakeStreamDirty ( TransactedSnapshotImpl *  This, DirRef  entry  )

static

Definition at line 5708 of file storage32.c.

{
  HRESULT hr = S_OK;
 
  if (!This->entries[entry].stream_dirty)
  {
    DirEntry new_entrydata;
 
    memset(&new_entrydata, 0, sizeof(DirEntry));
    new_entrydata.name[0] = 'S';
    new_entrydata.sizeOfNameString = 1;
    new_entrydata.stgType = STGTY_STREAM;
    new_entrydata.startingBlock = BLOCK_END_OF_CHAIN;
    new_entrydata.leftChild = DIRENTRY_NULL;
    new_entrydata.rightChild = DIRENTRY_NULL;
    new_entrydata.dirRootEntry = DIRENTRY_NULL;
 
    hr = StorageBaseImpl_CreateDirEntry(This->scratch, &new_entrydata,
      &This->entries[entry].stream_entry);
 
    if (SUCCEEDED(hr) && This->entries[entry].transactedParentEntry != DIRENTRY_NULL)
    {
      hr = StorageBaseImpl_CopyStream(
        This->scratch, This->entries[entry].stream_entry,
        This->transactedParent, This->entries[entry].transactedParentEntry);
 
      if (FAILED(hr))
        StorageBaseImpl_DestroyDirEntry(This->scratch, This->entries[entry].stream_entry);
    }
 
    if (SUCCEEDED(hr))
      This->entries[entry].stream_dirty = TRUE;
 
    if (This->entries[entry].transactedParentEntry != DIRENTRY_NULL)
    {
      /* Since this entry is modified, and we aren't using its stream data, we
       * no longer care about the original entry. */
      DirRef delete_ref;
      delete_ref = TransactedSnapshotImpl_CreateStubEntry(This, This->entries[entry].transactedParentEntry);
 
      if (delete_ref != DIRENTRY_NULL)
        This->entries[delete_ref].deleted = TRUE;
 
      This->entries[entry].transactedParentEntry = This->entries[entry].newTransactedParentEntry = DIRENTRY_NULL;
    }
  }
 
  return hr;
}

Referenced by TransactedSnapshotImpl_StreamSetSize(), and TransactedSnapshotImpl_StreamWriteAt().

TransactedSnapshotImpl_ReadDirEntry()

static HRESULT TransactedSnapshotImpl_ReadDirEntry ( StorageBaseImpl *  base, DirRef  index, DirEntry *  data  )

static

Definition at line 6225 of file storage32.c.

{
  TransactedSnapshotImpl* This = (TransactedSnapshotImpl*) base;
  HRESULT hr;
 
  hr = TransactedSnapshotImpl_EnsureReadEntry(This, index);
  if (FAILED(hr))
  {
    TRACE("<-- %08x\n", hr);
    return hr;
  }
 
  memcpy(data, &This->entries[index].data, sizeof(DirEntry));
 
  TRACE("%x %s l=%x r=%x d=%x\n", index, debugstr_w(data->name), data->leftChild, data->rightChild, data->dirRootEntry);
 
  return S_OK;
}

TransactedSnapshotImpl_Revert()

static HRESULT WINAPI TransactedSnapshotImpl_Revert ( IStorage *  iface )

static

Definition at line 6092 of file storage32.c.

{
  TransactedSnapshotImpl* This = (TransactedSnapshotImpl*)impl_from_IStorage(iface);
  ULARGE_INTEGER zero;
  ULONG i;
 
  TRACE("(%p)\n", iface);
 
  /* Destroy the open objects. */
  StorageBaseImpl_DeleteAll(&This->base);
 
  /* Clear out the scratch file. */
  zero.QuadPart = 0;
  for (i=0; i<This->entries_size; i++)
  {
    if (This->entries[i].stream_dirty)
    {
      StorageBaseImpl_StreamSetSize(This->scratch, This->entries[i].stream_entry,
        zero);
 
      StorageBaseImpl_DestroyDirEntry(This->scratch, This->entries[i].stream_entry);
    }
  }
 
  memset(This->entries, 0, sizeof(TransactedDirEntry) * This->entries_size);
 
  This->firstFreeEntry = 0;
  This->base.storageDirEntry = TransactedSnapshotImpl_CreateStubEntry(This, This->transactedParent->storageDirEntry);
 
  return S_OK;
}

TransactedSnapshotImpl_SetTransactionSig()

static HRESULT TransactedSnapshotImpl_SetTransactionSig ( StorageBaseImpl *  base, ULONG  value  )

static

Definition at line 6418 of file storage32.c.

{
  return E_NOTIMPL;
}

TransactedSnapshotImpl_StreamLink()

static HRESULT TransactedSnapshotImpl_StreamLink ( StorageBaseImpl *  base, DirRef  dst, DirRef  src  )

static

Definition at line 6379 of file storage32.c.

{
  TransactedSnapshotImpl* This = (TransactedSnapshotImpl*) base;
  HRESULT hr;
  TransactedDirEntry *dst_entry, *src_entry;
 
  hr = TransactedSnapshotImpl_EnsureReadEntry(This, src);
  if (FAILED(hr))
  {
    TRACE("<-- %08x\n", hr);
    return hr;
  }
 
  hr = TransactedSnapshotImpl_EnsureReadEntry(This, dst);
  if (FAILED(hr))
  {
    TRACE("<-- %08x\n", hr);
    return hr;
  }
 
  dst_entry = &This->entries[dst];
  src_entry = &This->entries[src];
 
  dst_entry->stream_dirty = src_entry->stream_dirty;
  dst_entry->stream_entry = src_entry->stream_entry;
  dst_entry->transactedParentEntry = src_entry->transactedParentEntry;
  dst_entry->newTransactedParentEntry = src_entry->newTransactedParentEntry;
  dst_entry->data.size = src_entry->data.size;
 
  return S_OK;
}

TransactedSnapshotImpl_StreamReadAt()

static HRESULT TransactedSnapshotImpl_StreamReadAt ( StorageBaseImpl *  base, DirRef  index, ULARGE_INTEGER  offset, ULONG  size, void *  buffer, ULONG *  bytesRead  )

static

Definition at line 6267 of file storage32.c.

{
  TransactedSnapshotImpl* This = (TransactedSnapshotImpl*) base;
 
  if (This->entries[index].stream_dirty)
  {
    return StorageBaseImpl_StreamReadAt(This->scratch,
        This->entries[index].stream_entry, offset, size, buffer, bytesRead);
  }
  else if (This->entries[index].transactedParentEntry == DIRENTRY_NULL)
  {
    /* This stream doesn't live in the parent, and we haven't allocated storage
     * for it yet */
    *bytesRead = 0;
    return S_OK;
  }
  else
  {
    return StorageBaseImpl_StreamReadAt(This->transactedParent,
        This->entries[index].transactedParentEntry, offset, size, buffer, bytesRead);
  }
}

TransactedSnapshotImpl_StreamSetSize()

static HRESULT TransactedSnapshotImpl_StreamSetSize ( StorageBaseImpl *  base, DirRef  index, ULARGE_INTEGER  newsize  )

static

Definition at line 6323 of file storage32.c.

{
  TransactedSnapshotImpl* This = (TransactedSnapshotImpl*) base;
  HRESULT hr;
 
  hr = TransactedSnapshotImpl_EnsureReadEntry(This, index);
  if (FAILED(hr))
  {
    TRACE("<-- %08x\n", hr);
    return hr;
  }
 
  if (This->entries[index].data.size.QuadPart == newsize.QuadPart)
    return S_OK;
 
  if (newsize.QuadPart == 0)
  {
    /* Destroy any parent references or entries in the scratch file. */
    if (This->entries[index].stream_dirty)
    {
      ULARGE_INTEGER zero;
      zero.QuadPart = 0;
      StorageBaseImpl_StreamSetSize(This->scratch,
        This->entries[index].stream_entry, zero);
      StorageBaseImpl_DestroyDirEntry(This->scratch,
        This->entries[index].stream_entry);
      This->entries[index].stream_dirty = FALSE;
    }
    else if (This->entries[index].transactedParentEntry != DIRENTRY_NULL)
    {
      DirRef delete_ref;
      delete_ref = TransactedSnapshotImpl_CreateStubEntry(This, This->entries[index].transactedParentEntry);
 
      if (delete_ref != DIRENTRY_NULL)
        This->entries[delete_ref].deleted = TRUE;
 
      This->entries[index].transactedParentEntry = This->entries[index].newTransactedParentEntry = DIRENTRY_NULL;
    }
  }
  else
  {
    hr = TransactedSnapshotImpl_MakeStreamDirty(This, index);
    if (FAILED(hr)) return hr;
 
    hr = StorageBaseImpl_StreamSetSize(This->scratch,
      This->entries[index].stream_entry, newsize);
  }
 
  if (SUCCEEDED(hr))
    This->entries[index].data.size = newsize;
 
  TRACE("<-- %08x\n", hr);
  return hr;
}

TransactedSnapshotImpl_StreamWriteAt()

static HRESULT TransactedSnapshotImpl_StreamWriteAt ( StorageBaseImpl *  base, DirRef  index, ULARGE_INTEGER  offset, ULONG  size, const void *  buffer, ULONG *  bytesWritten  )

static

Definition at line 6291 of file storage32.c.

{
  TransactedSnapshotImpl* This = (TransactedSnapshotImpl*) base;
  HRESULT hr;
 
  hr = TransactedSnapshotImpl_EnsureReadEntry(This, index);
  if (FAILED(hr))
  {
    TRACE("<-- %08x\n", hr);
    return hr;
  }
 
  hr = TransactedSnapshotImpl_MakeStreamDirty(This, index);
  if (FAILED(hr))
  {
    TRACE("<-- %08x\n", hr);
    return hr;
  }
 
  hr = StorageBaseImpl_StreamWriteAt(This->scratch,
    This->entries[index].stream_entry, offset, size, buffer, bytesWritten);
 
  if (SUCCEEDED(hr) && size != 0)
    This->entries[index].data.size.QuadPart = max(
        This->entries[index].data.size.QuadPart,
        offset.QuadPart + size);
 
  TRACE("<-- %08x\n", hr);
  return hr;
}

TransactedSnapshotImpl_UnlockTransaction()

static HRESULT TransactedSnapshotImpl_UnlockTransaction ( StorageBaseImpl *  base, BOOL  write  )

static

Definition at line 6429 of file storage32.c.

{
  return E_NOTIMPL;
}

TransactedSnapshotImpl_WriteDirEntry()

static HRESULT TransactedSnapshotImpl_WriteDirEntry ( StorageBaseImpl *  base, DirRef  index, const DirEntry *  data  )

static

Definition at line 6186 of file storage32.c.

{
  TransactedSnapshotImpl* This = (TransactedSnapshotImpl*) base;
  HRESULT hr;
 
  TRACE("%x %s l=%x r=%x d=%x\n", index, debugstr_w(data->name), data->leftChild, data->rightChild, data->dirRootEntry);
 
  hr = TransactedSnapshotImpl_EnsureReadEntry(This, index);
  if (FAILED(hr))
  {
    TRACE("<-- %08x\n", hr);
    return hr;
  }
 
  memcpy(&This->entries[index].data, data, sizeof(DirEntry));
 
  if (index != This->base.storageDirEntry)
  {
    This->entries[index].dirty = TRUE;
 
    if (data->size.QuadPart == 0 &&
        This->entries[index].transactedParentEntry != DIRENTRY_NULL)
    {
      /* Since this entry is modified, and we aren't using its stream data, we
       * no longer care about the original entry. */
      DirRef delete_ref;
      delete_ref = TransactedSnapshotImpl_CreateStubEntry(This, This->entries[index].transactedParentEntry);
 
      if (delete_ref != DIRENTRY_NULL)
        This->entries[delete_ref].deleted = TRUE;
 
      This->entries[index].transactedParentEntry = This->entries[index].newTransactedParentEntry = DIRENTRY_NULL;
    }
  }
  TRACE("<-- S_OK\n");
  return S_OK;
}

UpdateRawDirEntry()

static void UpdateRawDirEntry ( BYTE *  buffer, const DirEntry *  newData  )

static

Definition at line 3239 of file storage32.c.

{
  memset(buffer, 0, RAW_DIRENTRY_SIZE);
 
  memcpy(
    buffer + OFFSET_PS_NAME,
    newData->name,
    DIRENTRY_NAME_BUFFER_LEN );
 
  memcpy(buffer + OFFSET_PS_STGTYPE, &newData->stgType, 1);
 
  StorageUtl_WriteWord(
    buffer,
      OFFSET_PS_NAMELENGTH,
      newData->sizeOfNameString);
 
  StorageUtl_WriteDWord(
    buffer,
      OFFSET_PS_LEFTCHILD,
      newData->leftChild);
 
  StorageUtl_WriteDWord(
    buffer,
      OFFSET_PS_RIGHTCHILD,
      newData->rightChild);
 
  StorageUtl_WriteDWord(
    buffer,
      OFFSET_PS_DIRROOT,
      newData->dirRootEntry);
 
  StorageUtl_WriteGUID(
    buffer,
      OFFSET_PS_GUID,
      &newData->clsid);
 
  StorageUtl_WriteDWord(
    buffer,
      OFFSET_PS_CTIMELOW,
      newData->ctime.dwLowDateTime);
 
  StorageUtl_WriteDWord(
    buffer,
      OFFSET_PS_CTIMEHIGH,
      newData->ctime.dwHighDateTime);
 
  StorageUtl_WriteDWord(
    buffer,
      OFFSET_PS_MTIMELOW,
      newData->mtime.dwLowDateTime);
 
  StorageUtl_WriteDWord(
    buffer,
      OFFSET_PS_MTIMEHIGH,
      newData->ctime.dwHighDateTime);
 
  StorageUtl_WriteDWord(
    buffer,
      OFFSET_PS_STARTBLOCK,
      newData->startingBlock);
 
  StorageUtl_WriteDWord(
    buffer,
      OFFSET_PS_SIZE,
      newData->size.u.LowPart);
 
  StorageUtl_WriteDWord(
    buffer,
      OFFSET_PS_SIZE_HIGH,
      newData->size.u.HighPart);
}

Referenced by StorageImpl_CreateDirEntry(), and StorageImpl_WriteDirEntry().

validateSTGM()

static HRESULT validateSTGM ( DWORD  stgm )

static

Definition at line 287 of file storage32.c.

{
  DWORD access = STGM_ACCESS_MODE(stgm);
  DWORD share  = STGM_SHARE_MODE(stgm);
  DWORD create = STGM_CREATE_MODE(stgm);
 
  if (stgm&~STGM_KNOWN_FLAGS)
  {
    ERR("unknown flags %08x\n", stgm);
    return E_FAIL;
  }
 
  switch (access)
  {
  case STGM_READ:
  case STGM_WRITE:
  case STGM_READWRITE:
    break;
  default:
    return E_FAIL;
  }
 
  switch (share)
  {
  case STGM_SHARE_DENY_NONE:
  case STGM_SHARE_DENY_READ:
  case STGM_SHARE_DENY_WRITE:
  case STGM_SHARE_EXCLUSIVE:
    break;
  case 0:
    if (!(stgm & STGM_TRANSACTED))
      return E_FAIL;
    break;
  default:
    return E_FAIL;
  }
 
  switch (create)
  {
  case STGM_CREATE:
  case STGM_FAILIFTHERE:
    break;
  default:
    return E_FAIL;
  }
 
  /*
   * STGM_DIRECT | STGM_TRANSACTED | STGM_SIMPLE
   */
  if ( (stgm & STGM_TRANSACTED) && (stgm & STGM_SIMPLE) )
      return E_FAIL;
 
  /*
   * STGM_CREATE | STGM_CONVERT
   * if both are false, STGM_FAILIFTHERE is set to TRUE
   */
  if ( create == STGM_CREATE && (stgm & STGM_CONVERT) )
    return E_FAIL;
 
  /*
   * STGM_NOSCRATCH requires STGM_TRANSACTED
   */
  if ( (stgm & STGM_NOSCRATCH) && !(stgm & STGM_TRANSACTED) )
    return E_FAIL;
 
  /*
   * STGM_NOSNAPSHOT requires STGM_TRANSACTED and
   * not STGM_SHARE_EXCLUSIVE or STGM_SHARE_DENY_WRITE`
   */
  if ( (stgm & STGM_NOSNAPSHOT) &&
        (!(stgm & STGM_TRANSACTED) ||
         share == STGM_SHARE_EXCLUSIVE ||
         share == STGM_SHARE_DENY_WRITE) )
    return E_FAIL;
 
  return S_OK;
}

Referenced by create_storagefile(), StgOpenStorage(), StgOpenStorageOnILockBytes(), StorageBaseImpl_CreateStorage(), StorageBaseImpl_CreateStream(), StorageBaseImpl_OpenStorage(), StorageBaseImpl_OpenStream(), and StorageImpl_Construct().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

storage

)

WriteClassStg()

HRESULT WINAPI WriteClassStg	(	IStorage *	pStg,
		REFCLSID	rclsid
	)

Definition at line 9078 of file storage32.c.

{
  if(!pStg)
    return E_INVALIDARG;
 
  if(!rclsid)
    return STG_E_INVALIDPOINTER;
 
  return IStorage_SetClass(pStg, rclsid);
}

Referenced by OleCreateStaticFromData(), OleSave(), test_hglobal_storage_stat(), test_overwrite(), test_storage_refcount(), test_streamenum(), test_transacted_shared(), and test_writeclassstg().

WriteClassStm()

HRESULT WINAPI WriteClassStm	(	IStream *	pStm,
		REFCLSID	rclsid
	)

Definition at line 9525 of file storage32.c.

{
    TRACE("(%p,%p)\n",pStm,rclsid);
 
    if (!pStm || !rclsid)
        return E_INVALIDARG;
 
    return IStream_Write(pStm,rclsid,sizeof(CLSID),NULL);
}

Referenced by OLECONVERT_CreateCompObjStream(), OleSaveToStream(), STORAGE_WriteCompObj(), and test_ReadClassStm().

WriteFmtUserTypeStg()

HRESULT WINAPI WriteFmtUserTypeStg	(	LPSTORAGE	pstg,
		CLIPFORMAT	cf,
		LPOLESTR	lpszUserType
	)

Definition at line 9356 of file storage32.c.

{
    STATSTG stat;
    HRESULT r;
    WCHAR szwClipName[0x40];
    CLSID clsid;
    LPWSTR wstrProgID = NULL;
    DWORD n;
 
    TRACE("(%p,%x,%s)\n",pstg,cf,debugstr_w(lpszUserType));
 
    /* get the clipboard format name */
    if( cf )
    {
        n = GetClipboardFormatNameW(cf, szwClipName, ARRAY_SIZE(szwClipName));
        szwClipName[n]=0;
    }
 
    TRACE("Clipboard name is %s\n", debugstr_w(szwClipName));
 
    r = IStorage_Stat(pstg, &stat, STATFLAG_NONAME);
    if(SUCCEEDED(r))
        clsid = stat.clsid;
    else
        clsid = CLSID_NULL;
 
    ProgIDFromCLSID(&clsid, &wstrProgID);
 
    TRACE("progid is %s\n",debugstr_w(wstrProgID));
 
    r = STORAGE_WriteCompObj( pstg, &clsid, lpszUserType,
            cf ? szwClipName : NULL, wstrProgID );
 
    CoTaskMemFree(wstrProgID);
 
    return r;
}

Referenced by OleCreateStaticFromData(), OleDoAutoConvert(), test_fmtusertypestg(), and test_OleDoAutoConvert().

Variable Documentation

DirectWriterLockVtbl

const IDirectWriterLockVtbl DirectWriterLockVtbl

static

Initial value:

=
{
  directwriterlock_QueryInterface,
  directwriterlock_AddRef,
  directwriterlock_Release,
  directwriterlock_WaitForWriteAccess,
  directwriterlock_ReleaseWriteAccess,
  directwriterlock_HaveWriteAccess
}

Definition at line 484 of file storage32.c.

Referenced by StorageImpl_Construct().

IEnumSTATSTGImpl_Vtbl

const IEnumSTATSTGVtbl IEnumSTATSTGImpl_Vtbl

static

Initial value:

=
{
    IEnumSTATSTGImpl_QueryInterface,
    IEnumSTATSTGImpl_AddRef,
    IEnumSTATSTGImpl_Release,
    IEnumSTATSTGImpl_Next,
    IEnumSTATSTGImpl_Skip,
    IEnumSTATSTGImpl_Reset,
    IEnumSTATSTGImpl_Clone
}

Definition at line 1176 of file storage32.c.

Referenced by IEnumSTATSTGImpl_Construct().

IPropertySetStorage_Vtbl

const IPropertySetStorageVtbl IPropertySetStorage_Vtbl

extern

Definition at line 2557 of file stg_prop.c.

Referenced by StorageImpl_Construct(), and StorageInternalImpl_Construct().

STORAGE_magic

const BYTE STORAGE_magic[8] ={0xd0,0xcf,0x11,0xe0,0xa1,0xb1,0x1a,0xe1}

static

Definition at line 61 of file storage32.c.

Referenced by OleConvertOLESTREAMToIStorage(), StgIsStorageFile(), StgIsStorageILockBytes(), StorageImpl_LoadFileHeader(), and StorageImpl_SaveFileHeader().

STORAGE_oldmagic

const BYTE STORAGE_oldmagic[8] ={0xd0,0xcf,0x11,0xe0,0x0e,0x11,0xfc,0x0d}

static

Definition at line 62 of file storage32.c.

Referenced by StorageImpl_LoadFileHeader().

StorageImpl_BaseVtbl

const StorageBaseImplVtbl StorageImpl_BaseVtbl

static

Initial value:

=
{
  StorageImpl_Destroy,
  StorageImpl_Invalidate,
  StorageImpl_Flush,
  StorageImpl_GetFilename,
  StorageImpl_CreateDirEntry,
  StorageImpl_BaseWriteDirEntry,
  StorageImpl_BaseReadDirEntry,
  StorageImpl_DestroyDirEntry,
  StorageImpl_StreamReadAt,
  StorageImpl_StreamWriteAt,
  StorageImpl_StreamSetSize,
  StorageImpl_StreamLink,
  StorageImpl_GetTransactionSig,
  StorageImpl_SetTransactionSig,
  StorageImpl_LockTransaction,
  StorageImpl_UnlockTransaction
}

Definition at line 5222 of file storage32.c.

Referenced by StorageImpl_Construct().

StorageImpl_Vtbl

const IStorageVtbl StorageImpl_Vtbl

static

Initial value:

=
{
    StorageBaseImpl_QueryInterface,
    StorageBaseImpl_AddRef,
    StorageBaseImpl_Release,
    StorageBaseImpl_CreateStream,
    StorageBaseImpl_OpenStream,
    StorageBaseImpl_CreateStorage,
    StorageBaseImpl_OpenStorage,
    StorageBaseImpl_CopyTo,
    StorageBaseImpl_MoveElementTo,
    StorageBaseImpl_Commit,
    StorageBaseImpl_Revert,
    StorageBaseImpl_EnumElements,
    StorageBaseImpl_DestroyElement,
    StorageBaseImpl_RenameElement,
    StorageBaseImpl_SetElementTimes,
    StorageBaseImpl_SetClass,
    StorageBaseImpl_SetStateBits,
    StorageBaseImpl_Stat
}

Definition at line 5246 of file storage32.c.

Referenced by StorageImpl_Construct().

StorageInternalImpl_BaseVtbl

const StorageBaseImplVtbl StorageInternalImpl_BaseVtbl

static

Initial value:

=
{
  StorageInternalImpl_Destroy,
  StorageInternalImpl_Invalidate,
  StorageInternalImpl_Flush,
  StorageInternalImpl_GetFilename,
  StorageInternalImpl_CreateDirEntry,
  StorageInternalImpl_WriteDirEntry,
  StorageInternalImpl_ReadDirEntry,
  StorageInternalImpl_DestroyDirEntry,
  StorageInternalImpl_StreamReadAt,
  StorageInternalImpl_StreamWriteAt,
  StorageInternalImpl_StreamSetSize,
  StorageInternalImpl_StreamLink,
  StorageInternalImpl_GetTransactionSig,
  StorageInternalImpl_SetTransactionSig,
  StorageInternalImpl_LockTransaction,
  StorageInternalImpl_UnlockTransaction
}

Definition at line 5546 of file storage32.c.

Referenced by StorageInternalImpl_Construct().

StorageInternalImpl_Vtbl

static const IStorageVtbl StorageInternalImpl_Vtbl

static

Initial value:

=
{
    StorageBaseImpl_QueryInterface,
    StorageBaseImpl_AddRef,
    StorageBaseImpl_Release,
    StorageBaseImpl_CreateStream,
    StorageBaseImpl_OpenStream,
    StorageBaseImpl_CreateStorage,
    StorageBaseImpl_OpenStorage,
    StorageBaseImpl_CopyTo,
    StorageBaseImpl_MoveElementTo,
    StorageInternalImpl_Commit,
    StorageInternalImpl_Revert,
    StorageBaseImpl_EnumElements,
    StorageBaseImpl_DestroyElement,
    StorageBaseImpl_RenameElement,
    StorageBaseImpl_SetElementTimes,
    StorageBaseImpl_SetClass,
    StorageBaseImpl_SetStateBits,
    StorageBaseImpl_Stat
}

Definition at line 86 of file storage32.c.

Referenced by StorageBaseImpl_CopyTo(), and StorageInternalImpl_Construct().

TransactedSharedImpl_BaseVtbl

const StorageBaseImplVtbl TransactedSharedImpl_BaseVtbl

static

Initial value:

=
{
  TransactedSharedImpl_Destroy,
  TransactedSharedImpl_Invalidate,
  TransactedSharedImpl_Flush,
  TransactedSharedImpl_GetFilename,
  TransactedSharedImpl_CreateDirEntry,
  TransactedSharedImpl_WriteDirEntry,
  TransactedSharedImpl_ReadDirEntry,
  TransactedSharedImpl_DestroyDirEntry,
  TransactedSharedImpl_StreamReadAt,
  TransactedSharedImpl_StreamWriteAt,
  TransactedSharedImpl_StreamSetSize,
  TransactedSharedImpl_StreamLink,
  TransactedSharedImpl_GetTransactionSig,
  TransactedSharedImpl_SetTransactionSig,
  TransactedSharedImpl_LockTransaction,
  TransactedSharedImpl_UnlockTransaction
}

Definition at line 6792 of file storage32.c.

Referenced by TransactedSharedImpl_Construct().

TransactedSharedImpl_Vtbl

const IStorageVtbl TransactedSharedImpl_Vtbl

static

Initial value:

=
{
    StorageBaseImpl_QueryInterface,
    StorageBaseImpl_AddRef,
    StorageBaseImpl_Release,
    StorageBaseImpl_CreateStream,
    StorageBaseImpl_OpenStream,
    StorageBaseImpl_CreateStorage,
    StorageBaseImpl_OpenStorage,
    StorageBaseImpl_CopyTo,
    StorageBaseImpl_MoveElementTo,
    TransactedSharedImpl_Commit,
    TransactedSharedImpl_Revert,
    StorageBaseImpl_EnumElements,
    StorageBaseImpl_DestroyElement,
    StorageBaseImpl_RenameElement,
    StorageBaseImpl_SetElementTimes,
    StorageBaseImpl_SetClass,
    StorageBaseImpl_SetStateBits,
    StorageBaseImpl_Stat
}

Definition at line 6770 of file storage32.c.

Referenced by TransactedSharedImpl_Construct().

TransactedSnapshotImpl_BaseVtbl

const StorageBaseImplVtbl TransactedSnapshotImpl_BaseVtbl

static

Initial value:

=
{
  TransactedSnapshotImpl_Destroy,
  TransactedSnapshotImpl_Invalidate,
  TransactedSnapshotImpl_Flush,
  TransactedSnapshotImpl_GetFilename,
  TransactedSnapshotImpl_CreateDirEntry,
  TransactedSnapshotImpl_WriteDirEntry,
  TransactedSnapshotImpl_ReadDirEntry,
  TransactedSnapshotImpl_DestroyDirEntry,
  TransactedSnapshotImpl_StreamReadAt,
  TransactedSnapshotImpl_StreamWriteAt,
  TransactedSnapshotImpl_StreamSetSize,
  TransactedSnapshotImpl_StreamLink,
  TransactedSnapshotImpl_GetTransactionSig,
  TransactedSnapshotImpl_SetTransactionSig,
  TransactedSnapshotImpl_LockTransaction,
  TransactedSnapshotImpl_UnlockTransaction
}

Definition at line 6456 of file storage32.c.

Referenced by TransactedSnapshotImpl_Construct().

TransactedSnapshotImpl_Vtbl

static const IStorageVtbl TransactedSnapshotImpl_Vtbl

static

Initial value:

=
{
    StorageBaseImpl_QueryInterface,
    StorageBaseImpl_AddRef,
    StorageBaseImpl_Release,
    StorageBaseImpl_CreateStream,
    StorageBaseImpl_OpenStream,
    StorageBaseImpl_CreateStorage,
    StorageBaseImpl_OpenStorage,
    StorageBaseImpl_CopyTo,
    StorageBaseImpl_MoveElementTo,
    TransactedSnapshotImpl_Commit,
    TransactedSnapshotImpl_Revert,
    StorageBaseImpl_EnumElements,
    StorageBaseImpl_DestroyElement,
    StorageBaseImpl_RenameElement,
    StorageBaseImpl_SetElementTimes,
    StorageBaseImpl_SetClass,
    StorageBaseImpl_SetStateBits,
    StorageBaseImpl_Stat
}

Definition at line 155 of file storage32.c.

Referenced by StorageBaseImpl_CopyTo(), and TransactedSnapshotImpl_Construct().