ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Added an implementation of the OLE structured storage. The main 

features of this implementation are:
- Can open storages created in Windows.
- Can create new storages that the windows libraries can
  read.
- Provides all the functionality to create/open/remove and
  rename streams and storages inside the main storage object.
This commit is contained in:
Francis Beaudet 1999-01-30 13:24:23 +00:00 committed by Alexandre Julliard
parent b77de0298d
commit d92b9475a9
8 changed files with 6951 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
include/wine/obj_storage.h
View File

@ -93,6 +93,30 @@ DECL_WINELIB_TYPE(LPSTREAM)
#define STGM_NOSCRATCH 0x00100000
#define STGM_NOSNAPSHOT 0x00200000
/*****************************************************************************
* STGTY enumeration
*
* See IStorage
*/
#define STGTY_STORAGE 1
#define STGTY_STREAM 2
/*****************************************************************************
* STATFLAG enumeration
*
* See IStorage and IStream
*/
#define STATFLAG_DEFAULT 0
#define STATFLAG_NONAME 1
/*****************************************************************************
* STREAM_SEEK enumeration
*
* See IStream
*/
#define STREAM_SEEK_SET 0
#define STREAM_SEEK_CUR 1
#define STREAM_SEEK_END 2
/*****************************************************************************
* STATSTG structure
@ -115,8 +139,26 @@ struct STATSTG {
/*****************************************************************************
* IEnumSTATSTG interface
*/
/* FIXME: not implemented */
#define ICOM_INTERFACE IEnumSTATSTG
ICOM_BEGIN(IEnumSTATSTG,IUnknown)
ICOM_METHOD3(HRESULT, Next, ULONG, celt, STATSTG*, rgelt, ULONG*, pceltFetched);
ICOM_METHOD1(HRESULT, Skip, ULONG, celt);
ICOM_CMETHOD(HRESULT, Reset);
ICOM_METHOD1(HRESULT, Clone, IEnumSTATSTG**, ppenum);
ICOM_END(IEnumSTATSTG)
#undef ICOM_INTERFACE
#if !defined(__cplusplus) || defined(CINTERFACE)
/*** IUnknown methods ***/
#define IEnumSTATSTG_QueryInterface(p,a,b) ICOM_ICALL2(IUnknown,QueryInterface,p,a,b)
#define IEnumSTATSTG_AddRef(p) ICOM_ICALL (IUnknown,AddRef,p)
#define IEnumSTATSTG_Release(p) ICOM_ICALL (IUnknown,Release,p)
/*** IEnumSTATSTG methods ***/
#define IEnumSTATSTG_Next(p,a,b,c) ICOM_CALL3(Next,p,a,b,c)
#define IEnumSTATSTG_Skip(p,a) ICOM_CALL1(Skip,p,a)
#define IEnumSTATSTG_Reset(p) ICOM_CALL(Reset,p)
#define IEnumSTATSTG_Clone(p,a) ICOM_CALL1(Clone,p,a)
#endif
/*****************************************************************************
* IFillLockBytes interface
@ -426,8 +468,8 @@ ICOM_END(IStream32)
#define IStream32_Read(p,a,b,c) ICOM_ICALL3(ISequentialStream,Read,p,a,b,c)
#define IStream32_Write(p,a,b,c) ICOM_ICALL3(ISequentialStream,Write,p,a,b,c)
/*** IStream32 methods ***/
#define IStream32_Seek(p) ICOM_CALL3(Seek,p)
#define IStream32_SetSize(p,a,b) ICOM_CALL1(SetSize,p,a,b)
#define IStream32_Seek(p,a,b,c) ICOM_CALL3(Seek,p,a,b,c)
#define IStream32_SetSize(p,a) ICOM_CALL1(SetSize,p,a)
#define IStream32_CopyTo(pa,b,c,d) ICOM_CALL4(CopyTo,pa,b,c,d)
#define IStream32_Commit(p,a) ICOM_CALL1(Commit,p,a)
#define IStream32_Revert(p) ICOM_CALL (Revert,p)
@ -446,8 +488,8 @@ ICOM_END(IStream32)
#define IStream_Read(p,a,b,c) ICOM_ICALL3(ISequentialStream,Read,p,a,b,c)
#define IStream_Write(p,a,b,c) ICOM_ICALL3(ISequentialStream,Write,p,a,b,c)
/*** IStream methods ***/
#define IStream_Seek(p) ICOM_CALL3(Seek,p)
#define IStream_SetSize(p,a,b) ICOM_CALL1(SetSize,p,a,b)
#define IStream_Seek(p,a,b,c) ICOM_CALL3(Seek,p,a,b,c)
#define IStream_SetSize(p,a) ICOM_CALL1(SetSize,p,a)
#define IStream_CopyTo(pa,b,c,d) ICOM_CALL4(CopyTo,pa,b,c,d)
#define IStream_Commit(p,a) ICOM_CALL1(Commit,p,a)
#define IStream_Revert(p) ICOM_CALL (Revert,p)
@ -475,6 +517,7 @@ HRESULT WINAPI StgOpenStorage16(const OLECHAR16* pwcsName,IStorage16* pstgPriori
HRESULT WINAPI StgOpenStorage32(const OLECHAR32* pwcsName,IStorage32* pstgPriority,DWORD grfMode,SNB32 snbExclude,DWORD reserved,IStorage32**ppstgOpen);
#define StgOpenStorage WINELIB_NAME(StgOpenStorage)
HRESULT WINAPI WriteClassStg32(IStorage32* pStg, REFCLSID rclsid);
#define WriteClassStg WINELIB_NAME(WriteClassStg)
#endif /* __WINE_WINE_OBJ_STORAGE_H */

3
ole/Makefile.in
View File

@ -23,6 +23,9 @@ C_SRCS = \
parsedt.c \
safearray.c \
storage.c \
storage32.c \
stg_bigblockfile.c \
stg_stream.c \
typelib.c \
variant.c

826
ole/stg_bigblockfile.c Normal file
View File

@ -0,0 +1,826 @@
/******************************************************************************
*
* BigBlockFile
*
* This is the implementation of a file that consists of blocks of
* a predetermined size.
* This class is used in the Compound File implementation of the
* IStorage and IStream interfaces. It provides the functionality
* to read and write any blocks in the file as well as setting and
* obtaining the size of the file.
* The blocks are indexed sequentially from the start of the file
* starting with -1.
*
* TODO:
* - Support for a transacted mode
*
* Copyright 1999 Thuy Nguyen
*
*/
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "windows.h"
#include "winerror.h"
#include "ole.h"
#include "ole2.h"
#include "compobj.h"
#include "interfaces.h"
#include "storage32.h"
/***********************************************************
* Data structures used internally by the BigBlockFile
* class.
*/
/***
* Itdentifies a single big block and the related
* information
*/
struct BigBlock
{
BigBlock * next;
DWORD index;
DWORD access_mode;
LPVOID lpBlock;
};
/***
* This structure identifies the paged that are mapped
* from the file and their position in memory. It is
* also used to hold a reference count to those pages.
*/
struct MappedPage
{
MappedPage * next;
DWORD number;
int ref;
LPVOID lpBytes;
};
#define BLOCKS_PER_PAGE 128
#define PAGE_SIZE 65536
/***********************************************************
* Prototypes for private methods
*/
static void* BIGBLOCKFILE_GetMappedView(LPBIGBLOCKFILE This,
DWORD pagenum,
DWORD desired_access);
static void BIGBLOCKFILE_ReleaseMappedPage(LPBIGBLOCKFILE This,
DWORD pagenum,
DWORD access);
static void BIGBLOCKFILE_FreeAllMappedPages(LPBIGBLOCKFILE This);
static void* BIGBLOCKFILE_GetBigBlockPointer(LPBIGBLOCKFILE This,
ULONG index,
DWORD desired_access);
static BigBlock* BIGBLOCKFILE_GetBigBlockFromPointer(LPBIGBLOCKFILE This,
void* pBlock);
static void BIGBLOCKFILE_RemoveBlock(LPBIGBLOCKFILE This,
ULONG index);
static BigBlock* BIGBLOCKFILE_AddBigBlock(LPBIGBLOCKFILE This,
ULONG index);
static BigBlock* BIGBLOCKFILE_CreateBlock(ULONG index);
/******************************************************************************
* BIGBLOCKFILE_Construct
*
* Construct a big block file. Create the file mapping object.
* Create the read only mapped pages list, the writeable mapped page list
* and the blocks in use list.
*/
BigBlockFile * BIGBLOCKFILE_Construct(
HANDLE32 hFile,
ULONG blocksize)
{
LPBIGBLOCKFILE This;
This = (LPBIGBLOCKFILE)HeapAlloc(GetProcessHeap(), 0, sizeof(BigBlockFile));
if (This == NULL)
return NULL;
This->hfile = hFile;
if (This->hfile == INVALID_HANDLE_VALUE32)
{
HeapFree(GetProcessHeap(), 0, This);
return NULL;
}
/* create the file mapping object
*/
This->hfilemap = CreateFileMapping32A(This->hfile,
NULL,
PAGE_READWRITE,
0, 0,
NULL);
if (This->hfilemap == NULL)
{
CloseHandle(This->hfile);
HeapFree(GetProcessHeap(), 0, This);
return NULL;
}
/* initialize this
*/
This->filesize.LowPart = GetFileSize(This->hfile, NULL);
This->blocksize = blocksize;
/* create the read only mapped pages list
*/
This->headmap_ro = HeapAlloc(GetProcessHeap(), 0, sizeof(MappedPage));
if (This->headmap_ro == NULL)
{
CloseHandle(This->hfilemap);
CloseHandle(This->hfile);
HeapFree(GetProcessHeap(), 0, This);
return NULL;
}
This->headmap_ro->next = NULL;
/* create the writeable mapped pages list
*/
This->headmap_w = HeapAlloc(GetProcessHeap(), 0, sizeof(MappedPage));
if (This->headmap_w == NULL)
{
CloseHandle(This->hfilemap);
CloseHandle(This->hfile);
HeapFree(GetProcessHeap(), 0, This->headmap_ro);
HeapFree(GetProcessHeap(), 0, This);
return NULL;
}
This->headmap_w->next = NULL;
/* initialize the block list
*/
This->headblock = NULL;
return This;
}
/******************************************************************************
* BIGBLOCKFILE_Destructor
*
* Destructor. Clean up, free memory.
*/
void BIGBLOCKFILE_Destructor(
LPBIGBLOCKFILE This)
{
/* unmap all views and destroy the mapped page lists
*/
BIGBLOCKFILE_FreeAllMappedPages(This);
HeapFree(GetProcessHeap(), 0, This->headmap_ro);
HeapFree(GetProcessHeap(), 0, This->headmap_w);
/* close all open handles
*/
CloseHandle(This->hfilemap);
CloseHandle(This->hfile);
/* destroy this
*/
HeapFree(GetProcessHeap(), 0, This);
}
/******************************************************************************
* BIGBLOCKFILE_GetROBigBlock
*
* Returns the specified block in read only mode.
* Will return NULL if the block doesn't exists.
*/
void* BIGBLOCKFILE_GetROBigBlock(
LPBIGBLOCKFILE This,
ULONG index)
{
/*
* block index starts at -1
* translate to zero based index
*/
if (index == 0xffffffff)
index = 0;
else
index++;
/*
* validate the block index
*
*/
if ((This->blocksize * (index + 1)) >
(This->filesize.LowPart +
(This->blocksize - (This->filesize.LowPart % This->blocksize))))
return 0;
return BIGBLOCKFILE_GetBigBlockPointer(This, index, FILE_MAP_READ);
}
/******************************************************************************
* BIGBLOCKFILE_GetBigBlock
*
* Returns the specified block.
* Will grow the file if necessary.
*/
void* BIGBLOCKFILE_GetBigBlock(LPBIGBLOCKFILE This, ULONG index)
{
/*
* block index starts at -1
* translate to zero based index
*/
if (index == 0xffffffff)
index = 0;
else
index++;
/*
* make sure that the block physically exists
*/
if ((This->blocksize * (index + 1)) > This->filesize.LowPart)
{
ULARGE_INTEGER newSize;
newSize.HighPart = 0;
newSize.LowPart = This->blocksize * (index + 1);
BIGBLOCKFILE_SetSize(This, newSize);
}
return BIGBLOCKFILE_GetBigBlockPointer(This, index, FILE_MAP_WRITE);
}
/******************************************************************************
* BIGBLOCKFILE_ReleaseBigBlock
*
* Releases the specified block.
*
*/
void BIGBLOCKFILE_ReleaseBigBlock(LPBIGBLOCKFILE This, void *pBlock)
{
DWORD page_num;
BigBlock* theBigBlock;
if (pBlock == NULL)
return;
/*
* get the block from the block list
*/
theBigBlock = BIGBLOCKFILE_GetBigBlockFromPointer(This, pBlock);
if (theBigBlock == NULL)
return;
/*
* find out which page this block is in
*/
page_num = theBigBlock->index / BLOCKS_PER_PAGE;
/*
* release this page
*/
BIGBLOCKFILE_ReleaseMappedPage(This, page_num, theBigBlock->access_mode);
/*
* remove block from list
*/
BIGBLOCKFILE_RemoveBlock(This, theBigBlock->index);
}
/******************************************************************************
* BIGBLOCKFILE_SetSize
*
* Sets the size of the file.
*
*/
void BIGBLOCKFILE_SetSize(LPBIGBLOCKFILE This, ULARGE_INTEGER newSize)
{
if (This->filesize.LowPart == newSize.LowPart)
return;
/*
* unmap all views, must be done before call to SetEndFile
*/
BIGBLOCKFILE_FreeAllMappedPages(This);
/*
* close file-mapping object, must be done before call to SetEndFile
*/
CloseHandle(This->hfilemap);
This->hfilemap = NULL;
/*
* set the new end of file
*/
SetFilePointer(This->hfile, newSize.LowPart, NULL, FILE_BEGIN);
SetEndOfFile(This->hfile);
/*
* re-create the file mapping object
*/
This->hfilemap = CreateFileMapping32A(This->hfile,
NULL,
PAGE_READWRITE,
0, 0,
NULL);
This->filesize.LowPart = newSize.LowPart;
This->filesize.HighPart = newSize.HighPart;
}
/******************************************************************************
* BIGBLOCKFILE_GetSize
*
* Returns the size of the file.
*
*/
ULARGE_INTEGER BIGBLOCKFILE_GetSize(LPBIGBLOCKFILE This)
{
return This->filesize;
}
/******************************************************************************
* BIGBLOCKFILE_GetBigBlockPointer [PRIVATE]
*
* Returns a pointer to the specified block.
*/
static void* BIGBLOCKFILE_GetBigBlockPointer(
LPBIGBLOCKFILE This,
ULONG index,
DWORD desired_access)
{
DWORD page_num, block_num;
void * pBytes;
BigBlock *aBigBlock;
/* get the big block from the list or add it to the list
*/
aBigBlock = BIGBLOCKFILE_AddBigBlock(This, index);
if (aBigBlock == NULL)
return NULL;
/* we already have an address for this block
*/
if (aBigBlock->lpBlock != NULL)
{
/* make sure the desired access matches what we already have
*/
if (aBigBlock->access_mode == desired_access)
return aBigBlock->lpBlock;
else
return NULL;
}
/*
* else aBigBlock->lpBigBlock == NULL, it's a new block
*/
/* find out which page this block is in
*/
page_num = index / BLOCKS_PER_PAGE;
/* offset of the block in the page
*/
block_num = index % BLOCKS_PER_PAGE;
/* get a pointer to the first byte in the page
*/
pBytes = BIGBLOCKFILE_GetMappedView(This, page_num, desired_access);
if (pBytes == NULL)
return NULL;
/* initialize block
*/
aBigBlock->lpBlock = ((BYTE*)pBytes + (block_num*This->blocksize));
aBigBlock->access_mode = desired_access;
return aBigBlock->lpBlock;
}
/******************************************************************************
* BIGBLOCKFILE_CreateBlock [PRIVATE]
*
* Creates a node of the blocks list.
*/
static BigBlock* BIGBLOCKFILE_CreateBlock(
ULONG index)
{
BigBlock *newBigBlock;
/* create new list node
*/
newBigBlock = HeapAlloc(GetProcessHeap(), 0, sizeof(BigBlock));
if (newBigBlock == NULL)
return NULL;
/* initialize node
*/
newBigBlock->index = index;
newBigBlock->lpBlock = NULL;
return newBigBlock;
}
/******************************************************************************
* BIGBLOCKFILE_AddBigBlock [PRIVATE]
*
* Returns the specified block from the blocks list.
* If the block is not found in the list, we will create it and add it to the
* list.
*/
static BigBlock* BIGBLOCKFILE_AddBigBlock(
LPBIGBLOCKFILE This,
ULONG index)
{
BigBlock *current = This->headblock;
BigBlock *newBigBlock;
if (current == NULL) /* empty list */
{
newBigBlock = BIGBLOCKFILE_CreateBlock(index);
if (newBigBlock != NULL)
{
newBigBlock->next = NULL;
This->headblock = newBigBlock;
}
return newBigBlock;
}
else
{
/*
* special handling for head of the list
*/
if (current->index == index) /* it's already here */
return current;
else if (current->index > index) /* insertion at head of the list */
{
newBigBlock = BIGBLOCKFILE_CreateBlock(index);
if (newBigBlock != NULL)
{
newBigBlock->next = current;
This->headblock = newBigBlock;
}
return newBigBlock;
}
}
/* iterate through rest the list
*/
while (current->next != NULL)
{
if (current->next->index == index) /* found it */
{
return current->next;
}
else if (current->next->index > index) /* it's not in the list */
{
newBigBlock = BIGBLOCKFILE_CreateBlock(index);
if (newBigBlock != NULL)
{
newBigBlock->next = current->next;
current->next = newBigBlock;
}
return newBigBlock;
}
else
current = current->next;
}
/*
* insertion at end of the list
*/
if (current->next == NULL)
{
newBigBlock = BIGBLOCKFILE_CreateBlock(index);
if (newBigBlock != NULL)
{
newBigBlock->next = NULL;
current->next = newBigBlock;
}
return newBigBlock;
}
return NULL;
}
/******************************************************************************
* BIGBLOCKFILE_RemoveBlock [PRIVATE]
*
* Removes the specified block from the blocks list.
*/
static void BIGBLOCKFILE_RemoveBlock(
LPBIGBLOCKFILE This,
ULONG index)
{
BigBlock *current = This->headblock;
/*
* empty list
*/
if (current == NULL)
return;
/*
*special case: removing head of list
*/
if (current->index == index)
{
/*
* set new head free the old one
*/
This->headblock = current->next;
HeapFree(GetProcessHeap(), 0, current);
return;
}
/*
* iterate through rest of the list
*/
while (current->next != NULL)
{
if (current->next->index == index) /* found it */
{
/*
* unlink the block and free the block
*/
current->next = current->next->next;
HeapFree(GetProcessHeap(), 0, current->next);
return;
}
else
{
/* next node
*/
current = current->next;
}
}
}
/******************************************************************************
* BIGBLOCKFILE_GetBigBlockFromPointer [PRIVATE]
*
* Given a block pointer, this will return the corresponding block
* from the blocks list.
*/
static BigBlock* BIGBLOCKFILE_GetBigBlockFromPointer(
LPBIGBLOCKFILE This,
void* pBlock)
{
BigBlock *current = This->headblock;
while (current != NULL)
{
if (current->lpBlock == pBlock)
{
break;
}
else
current = current->next;
}
return current;
}
/******************************************************************************
* BIGBLOCKFILE_GetMappedView [PRIVATE]
*
* Gets the page requested if it is already mapped.
* If it's not already mapped, this method will map it
*/
static void * BIGBLOCKFILE_GetMappedView(
LPBIGBLOCKFILE This,
DWORD pagenum,
DWORD desired_access)
{
MappedPage * current;
MappedPage * newMappedPage;
DWORD hioffset, lowoffset;
/* use correct list
*/
if (desired_access == FILE_MAP_READ)
current = This->headmap_ro;
else if (desired_access == FILE_MAP_WRITE)
current = This->headmap_w;
else
return NULL;
hioffset = 0;
lowoffset = PAGE_SIZE * pagenum;
while (current->next != NULL)
{
if (current->next->number == pagenum) /* page already mapped */
{
current->next->ref++;
return current->next->lpBytes;
}
else if (current->next->number > pagenum) /* this page is not mapped yet */
{
/* allocate new MappedPage
*/
newMappedPage = HeapAlloc(GetProcessHeap(), 0, sizeof(MappedPage));
if (newMappedPage == NULL)
return NULL;
/* initialize the new MappedPage
*/
newMappedPage->number = pagenum;
newMappedPage->ref = 1;
newMappedPage->next = current->next;
current->next = newMappedPage;
/* actually map the page
*/
if (This->filesize.LowPart < PAGE_SIZE)
{
newMappedPage->lpBytes = MapViewOfFile(This->hfilemap,
desired_access,
hioffset, lowoffset,
This->filesize.LowPart);
}
else
{
newMappedPage->lpBytes = MapViewOfFile(This->hfilemap,
desired_access,
hioffset,
lowoffset,
PAGE_SIZE);
}
return newMappedPage->lpBytes;
}
else
current = current->next;
}
/* reached end of the list, this view is not mapped yet
*/
if (current->next == NULL)
{
/* allocate new MappedPage
*/
newMappedPage = HeapAlloc(GetProcessHeap(), 0, sizeof(MappedPage));
if (newMappedPage == NULL)
return NULL;
/* initialize the new MappedPage
*/
newMappedPage->number = pagenum;
newMappedPage->ref = 1;
newMappedPage->next = NULL;
current->next = newMappedPage;
/* actually map the page
*/
if (This->filesize.LowPart < PAGE_SIZE)
{
newMappedPage->lpBytes = MapViewOfFile(This->hfilemap,
desired_access,
hioffset,
lowoffset,
This->filesize.LowPart);
}
else
{
newMappedPage->lpBytes = MapViewOfFile(This->hfilemap,
desired_access,
hioffset,
lowoffset,
PAGE_SIZE);
}
return newMappedPage->lpBytes;
}
return NULL;
}
/******************************************************************************
* BIGBLOCKFILE_ReleaseMappedPage [PRIVATE]
*
* Decrements the reference count of the mapped page.
* If the page is not used anymore it will be unmapped.
*/
static void BIGBLOCKFILE_ReleaseMappedPage(
LPBIGBLOCKFILE This,
DWORD pagenum,
DWORD access)
{
MappedPage * previous;
MappedPage * current;
/* use the list corresponding to the desired access mode
*/
if (access == FILE_MAP_READ)
previous = This->headmap_ro;
else if (access == FILE_MAP_WRITE)
previous = This->headmap_w;
else
return;
current = previous->next;
/* search for the page in the list
*/
while (current != NULL)
{
if (current->number == pagenum)
{
/* decrement the reference count
*/
current->ref--;
if (current->ref == 0)
{
/* this page is not used anymore, we can unmap it
*/
UnmapViewOfFile(current->lpBytes);
previous->next = current->next;
HeapFree(GetProcessHeap(), 0, current);
}
return;
}
else
{
previous = current;
current = current->next;
}
}
}
/******************************************************************************
* BIGBLOCKFILE_FreeAllMappedPages [PRIVATE]
*
* Unmap all currently mapped pages.
* Empty both mapped pages lists.
*/
static void BIGBLOCKFILE_FreeAllMappedPages(
LPBIGBLOCKFILE This)
{
/*
* start with the read only list
*/
MappedPage * current = This->headmap_ro->next;
while (current != NULL)
{
/* unmap views
*/
UnmapViewOfFile(current->lpBytes);
/* free the nodes
*/
This->headmap_ro->next = current->next;
HeapFree(GetProcessHeap(), 0, current);
current = This->headmap_ro->next;
}
/*
* then do the write list
*/
current = This->headmap_w->next;
while (current != NULL)
{
/* unmap views
*/
UnmapViewOfFile(current->lpBytes);
/* free the nodes
*/
This->headmap_w->next = current->next;
HeapFree(GetProcessHeap(), 0, current);
current = This->headmap_w->next;
}
}

711
ole/stg_stream.c Normal file
View File

@ -0,0 +1,711 @@
/*
* Compound Storage (32 bit version)
* Stream implementation
*
* This file contains the implementation of the stream interface
* for streams contained in a compound storage.
*
* Copyright 1999 Francis Beaudet
* Copyright 1999 Thuy Nguyen
*/
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "windows.h"
#include "winerror.h"
#include "ole.h"
#include "ole2.h"
#include "compobj.h"
#include "interfaces.h"
#include "storage32.h"
/*
* Virtual function table for the StgStreamImpl class.
*/
static ICOM_VTABLE(IStream32) StgStreamImpl_Vtbl =
{
{
{
VTABLE_FUNC(StgStreamImpl_QueryInterface),
VTABLE_FUNC(StgStreamImpl_AddRef),
VTABLE_FUNC(StgStreamImpl_Release)
},
VTABLE_FUNC(StgStreamImpl_Read),
VTABLE_FUNC(StgStreamImpl_Write)
},
VTABLE_FUNC(StgStreamImpl_Seek),
VTABLE_FUNC(StgStreamImpl_SetSize),
VTABLE_FUNC(StgStreamImpl_CopyTo),
VTABLE_FUNC(StgStreamImpl_Commit),
VTABLE_FUNC(StgStreamImpl_Revert),
VTABLE_FUNC(StgStreamImpl_LockRegion),
VTABLE_FUNC(StgStreamImpl_UnlockRegion),
VTABLE_FUNC(StgStreamImpl_Stat),
VTABLE_FUNC(StgStreamImpl_Clone)
};
/******************************************************************************
** StgStreamImpl implementation
*/
/***
* This is the constructor for the StgStreamImpl class.
*
* Params:
* parentStorage - Pointer to the storage that contains the stream to open
* ownerProperty - Index of the property that points to this stream.
*/
StgStreamImpl* StgStreamImpl_Construct(
Storage32BaseImpl* parentStorage,
ULONG ownerProperty)
{
StgStreamImpl* newStream;
newStream = HeapAlloc(GetProcessHeap(), 0, sizeof(StgStreamImpl));
if (newStream!=0)
{
/*
* Set-up the virtual function table and reference count.
*/
newStream->lpvtbl = &StgStreamImpl_Vtbl;
newStream->ref = 0;
/*
* We want to nail-down the reference to the storage in case the
* stream out-lives the storage in the client application.
*/
newStream->parentStorage = parentStorage;
IStorage32_AddRef(newStream->parentStorage);
newStream->ownerProperty = ownerProperty;
/*
* Start the stream at the begining.
*/
newStream->currentPosition.HighPart = 0;
newStream->currentPosition.LowPart = 0;
/*
* Initialize the rest of the data.
*/
newStream->streamSize.HighPart = 0;
newStream->streamSize.LowPart = 0;
newStream->bigBlockChain = 0;
newStream->smallBlockChain = 0;
/*
* Read the size from the property and determine if the blocks forming
* this stream are large or small.
*/
StgStreamImpl_OpenBlockChain(newStream);
}
return newStream;
}
/***
* This is the destructor of the StgStreamImpl class.
*
* This method will clean-up all the resources used-up by the given StgStreamImpl
* class. The pointer passed-in to this function will be freed and will not
* be valid anymore.
*/
void StgStreamImpl_Destroy(StgStreamImpl* This)
{
/*
* Release the reference we are holding on the parent storage.
*/
IStorage32_Release(This->parentStorage);
This->parentStorage = 0;
/*
* Make sure we clean-up the block chain stream objects that we were using.
*/
if (This->bigBlockChain != 0)
{
BlockChainStream_Destroy(This->bigBlockChain);
This->bigBlockChain = 0;
}
if (This->smallBlockChain != 0)
{
SmallBlockChainStream_Destroy(This->smallBlockChain);
This->smallBlockChain = 0;
}
/*
* Finally, free the memory used-up by the class.
*/
HeapFree(GetProcessHeap(), 0, This);
}
/***
* This implements the IUnknown method QueryInterface for this
* class
*/
HRESULT WINAPI StgStreamImpl_QueryInterface(
StgStreamImpl* This,
REFIID riid, /* [in] */
void** ppvObject) /* [iid_is][out] */
{
/*
* Perform a sanity check on the parameters.
*/
if (ppvObject==0)
return E_INVALIDARG;
/*
* Initialize the return parameter.
*/
*ppvObject = 0;
/*
* Compare the riid with the interface IDs implemented by this object.
*/
if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0)
{
*ppvObject = (IStream32*)This;
}
else if (memcmp(&IID_IStorage, riid, sizeof(IID_IStream)) == 0)
{
*ppvObject = (IStream32*)This;
}
/*
* Check that we obtained an interface.
*/
if ((*ppvObject)==0)
return E_NOINTERFACE;
/*
* Query Interface always increases the reference count by one when it is
* successful
*/
StgStreamImpl_AddRef(This);
return S_OK;;
}
/***
* This implements the IUnknown method AddRef for this
* class
*/
ULONG WINAPI StgStreamImpl_AddRef(
StgStreamImpl* This)
{
This->ref++;
return This->ref;
}
/***
* This implements the IUnknown method Release for this
* class
*/
ULONG WINAPI StgStreamImpl_Release(
StgStreamImpl* This)
{
ULONG newRef;
This->ref--;
newRef = This->ref;
/*
* If the reference count goes down to 0, perform suicide.
*/
if (newRef==0)
{
StgStreamImpl_Destroy(This);
}
return newRef;
}
/***
* This method will open the block chain pointed by the property
* that describes the stream.
* If the stream's size is null, no chain is opened.
*/
void StgStreamImpl_OpenBlockChain(
StgStreamImpl* This)
{
StgProperty curProperty;
BOOL32 readSucessful;
/*
* Make sure no old object is staying behind.
*/
if (This->smallBlockChain != 0)
{
SmallBlockChainStream_Destroy(This->smallBlockChain);
This->smallBlockChain = 0;
}
if (This->bigBlockChain != 0)
{
BlockChainStream_Destroy(This->bigBlockChain);
This->bigBlockChain = 0;
}
/*
* Read the information from the property.
*/
readSucessful = Storage32Impl_ReadProperty(This->parentStorage->ancestorStorage,
This->ownerProperty,
&curProperty);
if (readSucessful)
{
This->streamSize = curProperty.size;
/*
* This code supports only streams that are <32 bits in size.
*/
assert(This->streamSize.HighPart == 0);
if(curProperty.startingBlock == BLOCK_END_OF_CHAIN)
{
assert( (This->streamSize.HighPart == 0) && (This->streamSize.LowPart == 0) );
}
else
{
if ( (This->streamSize.HighPart == 0) &&
(This->streamSize.LowPart < LIMIT_TO_USE_SMALL_BLOCK) )
{
This->smallBlockChain = SmallBlockChainStream_Construct(
This->parentStorage->ancestorStorage,
This->ownerProperty);
}
else
{
This->bigBlockChain = BlockChainStream_Construct(
This->parentStorage->ancestorStorage,
NULL,
This->ownerProperty);
}
}
}
}
/***
* This method is part of the ISequentialStream interface.
*
* If reads a block of information from the stream at the current
* position. It then moves the current position at the end of the
* read block
*
* See the documentation of ISequentialStream for more info.
*/
HRESULT WINAPI StgStreamImpl_Read(
StgStreamImpl* This,
void* pv, /* [length_is][size_is][out] */
ULONG cb, /* [in] */
ULONG* pcbRead) /* [out] */
{
ULONG bytesReadBuffer;
ULONG bytesToReadFromBuffer;
/*
* If the caller is not interested in the nubmer of bytes read,
* we use another buffer to avoid "if" statements in the code.
*/
if (pcbRead==0)
pcbRead = &bytesReadBuffer;
/*
* Using the known size of the stream, calculate the number of bytes
* to read from the block chain
*/
bytesToReadFromBuffer = MIN( This->streamSize.LowPart - This->currentPosition.LowPart, cb);
/*
* Depending on the type of chain that was opened when the stream was constructed,
* we delegate the work to the method that read the block chains.
*/
if (This->smallBlockChain!=0)
{
SmallBlockChainStream_ReadAt(This->smallBlockChain,
This->currentPosition,
bytesToReadFromBuffer,
pv,
pcbRead);
}
else if (This->bigBlockChain!=0)
{
BlockChainStream_ReadAt(This->bigBlockChain,
This->currentPosition,
bytesToReadFromBuffer,
pv,
pcbRead);
}
else
assert(FALSE);
/*
* We should always be able to read the proper amount of data from the
* chain.
*/
assert(bytesToReadFromBuffer == *pcbRead);
/*
* Advance the pointer for the number of positions read.
*/
This->currentPosition.LowPart += *pcbRead;
/*
* The function returns S_OK if the buffer was filled completely
* it returns S_FALSE if the end of the stream is reached before the
* buffer is filled
*/
if(*pcbRead == cb)
return S_OK;
return S_FALSE;
}
/***
* This method is part of the ISequentialStream interface.
*
* It writes a block of information to the stream at the current
* position. It then moves the current position at the end of the
* written block. If the stream is too small to fit the block,
* the stream is grown to fit.
*
* See the documentation of ISequentialStream for more info.
*/
HRESULT WINAPI StgStreamImpl_Write(
StgStreamImpl* This,
const void* pv, /* [size_is][in] */
ULONG cb, /* [in] */
ULONG* pcbWritten) /* [out] */
{
ULARGE_INTEGER newSize;
ULONG bytesWritten = 0;
/*
* If the caller is not interested in the number of bytes written,
* we use another buffer to avoid "if" statements in the code.
*/
if (pcbWritten == 0)
pcbWritten = &bytesWritten;
if (cb == 0)
{
return S_OK;
}
else
{
newSize.HighPart = 0;
newSize.LowPart = This->currentPosition.LowPart + cb;
}
/*
* Verify if we need to grow the stream
*/
if (newSize.LowPart > This->streamSize.LowPart)
{
/* grow stream */
StgStreamImpl_SetSize(This, newSize);
}
/*
* Depending on the type of chain that was opened when the stream was constructed,
* we delegate the work to the method that readwrites to the block chains.
*/
if (This->smallBlockChain!=0)
{
SmallBlockChainStream_WriteAt(This->smallBlockChain,
This->currentPosition,
cb,
pv,
pcbWritten);
}
else if (This->bigBlockChain!=0)
{
BlockChainStream_WriteAt(This->bigBlockChain,
This->currentPosition,
cb,
pv,
pcbWritten);
}
else
assert(FALSE);
/*
* Advance the position pointer for the number of positions written.
*/
This->currentPosition.LowPart += *pcbWritten;
return S_OK;
}
/***
* This method is part of the IStream interface.
*
* It will move the current stream pointer according to the parameters
* given.
*
* See the documentation of IStream for more info.
*/
HRESULT WINAPI StgStreamImpl_Seek(
StgStreamImpl* This,
LARGE_INTEGER dlibMove, /* [in] */
DWORD dwOrigin, /* [in] */
ULARGE_INTEGER* plibNewPosition) /* [out] */
{
ULARGE_INTEGER newPosition;
/*
* The caller is allowed to pass in NULL as the new position return value.
* If it happens, we assign it to a dynamic variable to avoid special cases
* in the code below.
*/
if (plibNewPosition == 0)
{
plibNewPosition = &newPosition;
}
/*
* The file pointer is moved depending on the given "function"
* parameter.
*/
switch (dwOrigin)
{
case STREAM_SEEK_SET:
plibNewPosition->HighPart = 0;
plibNewPosition->LowPart = 0;
break;
case STREAM_SEEK_CUR:
*plibNewPosition = This->currentPosition;
break;
case STREAM_SEEK_END:
*plibNewPosition = This->streamSize;
break;
default:
return STG_E_INVALIDFUNCTION;
}
/*
* We don't support files with offsets of 64 bits.
*/
assert(dlibMove.HighPart == 0);
/*
* Check if we end-up before the beginning of the file. That should trigger an
* error.
*/
if ( (dlibMove.LowPart<0) && (plibNewPosition->LowPart < (ULONG)(-dlibMove.LowPart)) )
{
/*
* I don't know what error to send there.
*/
return E_FAIL;
}
/*
* Move the actual file pointer
* If the file pointer ends-up after the end of the stream, the next Write operation will
* make the file larger. This is how it is documented.
*/
plibNewPosition->LowPart += dlibMove.LowPart;
This->currentPosition = *plibNewPosition;
return S_OK;
}
/***
* This method is part of the IStream interface.
*
* It will change the size of a stream.
*
* TODO: Switch from small blocks to big blocks and vice versa.
*
* See the documentation of IStream for more info.
*/
HRESULT WINAPI StgStreamImpl_SetSize(
StgStreamImpl* This,
ULARGE_INTEGER libNewSize) /* [in] */
{
StgProperty curProperty;
BOOL32 Success;
/*
* As documented.
*/
if (libNewSize.HighPart != 0)
return STG_E_INVALIDFUNCTION;
if (This->streamSize.LowPart == libNewSize.LowPart)
return S_OK;
/*
* This will happen if we're creating a stream
*/
if ((This->smallBlockChain == 0) && (This->bigBlockChain == 0))
{
if (libNewSize.LowPart < LIMIT_TO_USE_SMALL_BLOCK)
{
This->smallBlockChain = SmallBlockChainStream_Construct(
This->parentStorage->ancestorStorage,
This->ownerProperty);
}
else
{
This->bigBlockChain = BlockChainStream_Construct(
This->parentStorage->ancestorStorage,
NULL,
This->ownerProperty);
}
}
/*
* Read this stream's property to see if it's small blocks or big blocks
*/
Success = Storage32Impl_ReadProperty(This->parentStorage->ancestorStorage,
This->ownerProperty,
&curProperty);
/*
* TODO
* determine if we have to switch from small to big blocks or vice versa
*/
if (This->smallBlockChain!=0)
{
Success = SmallBlockChainStream_SetSize(This->smallBlockChain, libNewSize);
curProperty.blockType = SMALL_BLOCK_TYPE;
}
else
{
Success = BlockChainStream_SetSize(This->bigBlockChain, libNewSize);
curProperty.blockType = BIG_BLOCK_TYPE;
}
/*
* Write to the property the new information about this stream
*/
Success = Storage32Impl_ReadProperty(This->parentStorage->ancestorStorage,
This->ownerProperty,
&curProperty);
curProperty.size.HighPart = libNewSize.HighPart;
curProperty.size.LowPart = libNewSize.LowPart;
if (Success)
{
Storage32Impl_WriteProperty(This->parentStorage->ancestorStorage,
This->ownerProperty,
&curProperty);
}
This->streamSize = libNewSize;
return S_OK;
}
HRESULT WINAPI StgStreamImpl_CopyTo(
StgStreamImpl* This,
IStream32* pstm, /* [unique][in] */
ULARGE_INTEGER cb, /* [in] */
ULARGE_INTEGER* pcbRead, /* [out] */
ULARGE_INTEGER* pcbWritten) /* [out] */
{
return E_NOTIMPL;
}
/***
* This method is part of the IStream interface.
*
* For streams contained in structured storages, this method
* does nothing. This is what the documentation tells us.
*
* See the documentation of IStream for more info.
*/
HRESULT WINAPI StgStreamImpl_Commit(
StgStreamImpl* This,
DWORD grfCommitFlags) /* [in] */
{
return S_OK;
}
/***
* This method is part of the IStream interface.
*
* For streams contained in structured storages, this method
* does nothing. This is what the documentation tells us.
*
* See the documentation of IStream for more info.
*/
HRESULT WINAPI StgStreamImpl_Revert(
StgStreamImpl* This)
{
return S_OK;
}
HRESULT WINAPI StgStreamImpl_LockRegion(
StgStreamImpl* This,
ULARGE_INTEGER libOffset, /* [in] */
ULARGE_INTEGER cb, /* [in] */
DWORD dwLockType) /* [in] */
{
return E_NOTIMPL;
}
HRESULT WINAPI StgStreamImpl_UnlockRegion(
StgStreamImpl* This,
ULARGE_INTEGER libOffset, /* [in] */
ULARGE_INTEGER cb, /* [in] */
DWORD dwLockType) /* [in] */
{
return E_NOTIMPL;
}
/***
* This method is part of the IStream interface.
*
* This method returns information about the current
* stream.
*
* See the documentation of IStream for more info.
*/
HRESULT WINAPI StgStreamImpl_Stat(
StgStreamImpl* This,
STATSTG* pstatstg, /* [out] */
DWORD grfStatFlag) /* [in] */
{
StgProperty curProperty;
BOOL32 readSucessful;
/*
* Read the information from the property.
*/
readSucessful = Storage32Impl_ReadProperty(This->parentStorage->ancestorStorage,
This->ownerProperty,
&curProperty);
if (readSucessful)
{
StorageUtl_CopyPropertyToSTATSTG(pstatstg,
&curProperty,
grfStatFlag);
return S_OK;
}
return E_FAIL;
}
HRESULT WINAPI StgStreamImpl_Clone(
StgStreamImpl* This,
IStream32** ppstm) /* [out] */
{
return E_NOTIMPL;
}

159
ole/storage.c
View File

@ -66,10 +66,8 @@ static const BYTE STORAGE_oldmagic[8]={0xd0,0xcf,0x11,0xe0,0x0e,0x11,0xfc,0x0d};
#define READ_HEADER assert(STORAGE_get_big_block(hf,-1,(LPBYTE)&sth));assert(!memcmp(STORAGE_magic,sth.magic,sizeof(STORAGE_magic)));
static ICOM_VTABLE(IStorage16) stvt16;
static ICOM_VTABLE(IStorage16) *segstvt16 = NULL;
static ICOM_VTABLE(IStorage32) stvt32;
static ICOM_VTABLE(IStream16) strvt16;
static ICOM_VTABLE(IStream16) *segstrvt16 = NULL;
static ICOM_VTABLE(IStream32) strvt32;
/*ULONG WINAPI IStorage16_AddRef(LPSTORAGE16 this);*/
static void _create_istorage16(LPSTORAGE16 *stg);
@ -1211,25 +1209,6 @@ ULONG WINAPI IStream32_fnRelease(LPUNKNOWN iface) {
return this->ref;
}
static ICOM_VTABLE(IStream32) strvt32 = {
{
{
IStream32_fnQueryInterface,
IStream32_fnAddRef,
IStream32_fnRelease
},
(void*)0xdead0004,
(void*)0xdead0005
},
(void*)0xdead0006,
(void*)0xdead0007,
(void*)0xdead0008,
(void*)0xdead0009,
(void*)0xdead0010,
(void*)0xdead0011
};
/* --- IStorage16 implementation */
typedef struct _IStorage16 {
@ -1591,114 +1570,6 @@ static void _create_istorage16(LPSTORAGE16 *stg) {
*stg = (void*)lpst->thisptr;
}
/* --- IStorage32 implementation */
typedef struct _IStorage32 {
/* IUnknown fields */
ICOM_VTABLE(IStorage32)* lpvtbl;
DWORD ref;
/* IStorage32 fields */
struct storage_pps_entry stde;
int ppsent;
HFILE32 hf;
} _IStorage32;
/******************************************************************************
* IStorage32_QueryInterface [VTABLE]
*/
HRESULT WINAPI IStorage32_fnQueryInterface(
LPUNKNOWN iface,REFIID refiid,LPVOID *obj
) {
ICOM_THIS(IStorage32,iface);
char xrefiid[50];
WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
TRACE(relay,"(%p)->(%s,%p)\n",this,xrefiid,obj);
if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
*obj = this;
return 0;
}
return OLE_E_ENUM_NOMORE;
}
/******************************************************************************
* IStorage32_AddRef [VTABLE]
*/
ULONG WINAPI IStorage32_fnAddRef(LPUNKNOWN iface) {
ICOM_THIS(IStorage32,iface);
return ++(this->ref);
}
/******************************************************************************
* IStorage32_Release [VTABLE]
*/
ULONG WINAPI IStorage32_fnRelease(LPUNKNOWN iface) {
ICOM_THIS(IStorage32,iface);
this->ref--;
if (this->ref)
return this->ref;
HeapFree(GetProcessHeap(),0,this);
return 0;
}
/******************************************************************************
* IStorage32_CreateStream [VTABLE]
*/
HRESULT WINAPI IStorage32_fnCreateStream(
LPSTORAGE32 iface,LPCOLESTR32 pwcsName,DWORD grfMode,DWORD reserved1,DWORD reserved2, IStream32 **ppstm
) {
ICOM_THIS(IStorage32,iface);
TRACE(ole,"(%p)->(%p,0x%08lx,0x%08lx,0x%08lx,%p)\n",
this,pwcsName,grfMode,reserved1,reserved2,ppstm
);
*ppstm = (IStream32*)HeapAlloc(GetProcessHeap(),0,sizeof(IStream32));
((_IStream32*)(*ppstm))->lpvtbl= &strvt32;
((_IStream32*)(*ppstm))->ref = 1;
return S_OK;
}
/******************************************************************************
* IStorage32_OpenStream [VTABLE]
*/
HRESULT WINAPI IStorage32_fnOpenStream(
LPSTORAGE32 iface,LPCOLESTR32 pwcsName, void *reserved1, DWORD grfMode, DWORD reserved2, IStream32 **ppstm
) {
ICOM_THIS(IStorage32,iface);
TRACE(ole,"(%p)->(%p,%p,0x%08lx,0x%08lx,%p)\n",
this,pwcsName,reserved1,grfMode,reserved2,ppstm
);
*ppstm = (IStream32*)HeapAlloc(GetProcessHeap(),0,sizeof(IStream32));
((_IStream32*)(*ppstm))->lpvtbl= &strvt32;
((_IStream32*)(*ppstm))->ref = 1;
return S_OK;
}
static ICOM_VTABLE(IStorage32) stvt32 = {
{
IStorage32_fnQueryInterface,
IStorage32_fnAddRef,
IStorage32_fnRelease
},
IStorage32_fnCreateStream,
IStorage32_fnOpenStream,
(void*)0xdead0006,
(void*)0xdead0007,
(void*)0xdead0008,
(void*)0xdead0009,
(void*)0xdead0010,
(void*)0xdead0011,
(void*)0xdead0012,
(void*)0xdead0013,
(void*)0xdead0014,
(void*)0xdead0015,
(void*)0xdead0016,
(void*)0xdead0017,
(void*)0xdead0018,
};
/******************************************************************************
* Storage API functions
*/
@ -1744,21 +1615,7 @@ HRESULT WINAPI StgCreateDocFile16(
IStorage16_fnRelease((IUnknown*)lpstg); /* will remove it */
return E_FAIL;
}
return S_OK;
}
/******************************************************************************
* StgCreateDocfile32 [OLE32.144]
*/
HRESULT WINAPI StgCreateDocfile32(
LPCOLESTR32 pwcsName,DWORD grfMode,DWORD reserved,IStorage32 **ppstgOpen
) {
TRACE(ole,"(%p,0x%08lx,0x%08lx,%p)\n",
pwcsName,grfMode,reserved,ppstgOpen
);
*ppstgOpen = (IStorage32*)HeapAlloc(GetProcessHeap(),0,sizeof(IStorage32));
((_IStorage32*)(*ppstgOpen))->ref = 1;
((_IStorage32*)(*ppstgOpen))->lpvtbl = &stvt32;
return S_OK;
}
@ -1854,20 +1711,4 @@ HRESULT WINAPI StgOpenStorage16(
}
/******************************************************************************
* StgOpenStorage32 [OLE32.148]
*/
HRESULT WINAPI StgOpenStorage32(
const OLECHAR32 * pwcsName,IStorage32 *pstgPriority,DWORD grfMode,
SNB32 snbExclude,DWORD reserved, IStorage32 **ppstgOpen
) {
FIXME(ole,"StgOpenStorage32(%p,%p,0x%08lx,%p,%ld,%p),stub!\n",
pwcsName,pstgPriority,grfMode,snbExclude,reserved,
ppstgOpen);
*ppstgOpen = (IStorage32*)HeapAlloc(GetProcessHeap(),0,sizeof(IStorage32));
((_IStorage32*)(*ppstgOpen))->ref = 1;
((_IStorage32*)(*ppstgOpen))->lpvtbl = &stvt32;
return S_OK;
}

4531
ole/storage32.c Normal file
View File

File diff suppressed because it is too large Load Diff

830
ole/storage32.h Normal file
View File

@ -0,0 +1,830 @@
/*
* Compound Storage (32 bit version)
*
* Implemented using the documentation of the LAOLA project at
* <URL:http://wwwwbs.cs.tu-berlin.de/~schwartz/pmh/index.html>
* (Thanks to Martin Schwartz <schwartz@cs.tu-berlin.de>)
*
* This include file contains definitions of types and function
* prototypes that are used in the many files implementing the
* storage functionality
*
* Copyright 1998,1999 Francis Beaudet
* Copyright 1998,1999 Thuy Nguyen
*/
#ifndef __STORAGE32_H__
#define __STORAGE32_H__
/*
* Definitions for the file format offsets.
*/
static const ULONG OFFSET_BIGBLOCKSIZEBITS = 0x0000001e;
static const ULONG OFFSET_SMALLBLOCKSIZEBITS = 0x00000020;
static const ULONG OFFSET_BBDEPOTCOUNT = 0x0000002C;
static const ULONG OFFSET_ROOTSTARTBLOCK = 0x00000030;
static const ULONG OFFSET_SBDEPOTSTART = 0x0000003C;
static const ULONG OFFSET_EXTBBDEPOTSTART = 0x00000044;
static const ULONG OFFSET_EXTBBDEPOTCOUNT = 0x00000048;
static const ULONG OFFSET_BBDEPOTSTART = 0x0000004C;
static const OFFSET_PS_NAME = 0x00000000;
static const OFFSET_PS_NAMELENGTH = 0x00000040;
static const OFFSET_PS_PROPERTYTYPE = 0x00000042;
static const OFFSET_PS_BLOCKTYPE = 0x00000043;
static const OFFSET_PS_PREVIOUSPROP = 0x00000044;
static const OFFSET_PS_NEXTPROP = 0x00000048;
static const OFFSET_PS_DIRPROP = 0x0000004C;
static const OFFSET_PS_GUID = 0x00000050;
static const OFFSET_PS_TSS1 = 0x00000064;
static const OFFSET_PS_TSD1 = 0x00000068;
static const OFFSET_PS_TSS2 = 0x0000006C;
static const OFFSET_PS_TSD2 = 0x00000070;
static const OFFSET_PS_STARTBLOCK = 0x00000074;
static const OFFSET_PS_SIZE = 0x00000078;
static const WORD DEF_BIG_BLOCK_SIZE_BITS = 0x0009;
static const WORD DEF_SMALL_BLOCK_SIZE_BITS = 0x0006;
static const WORD DEF_BIG_BLOCK_SIZE = 0x0200;
static const WORD DEF_SMALL_BLOCK_SIZE = 0x0040;
static const ULONG BLOCK_SPECIAL = 0xFFFFFFFD;
static const ULONG BLOCK_END_OF_CHAIN = 0xFFFFFFFE;
static const ULONG BLOCK_UNUSED = 0xFFFFFFFF;
static const ULONG PROPERTY_NULL = 0xFFFFFFFF;
#define PROPERTY_NAME_MAX_LEN 0x20
#define PROPERTY_NAME_BUFFER_LEN 0x40
#define PROPSET_BLOCK_SIZE 0x00000080
/*
* Property type of relation
*/
#define PROPERTY_RELATION_PREVIOUS 0
#define PROPERTY_RELATION_NEXT 1
#define PROPERTY_RELATION_DIR 2
/*
* Property type constants
*/
#define PROPTYPE_STORAGE 0x01
#define PROPTYPE_STREAM 0x02
#define PROPTYPE_ROOT 0x05
/*
* Block type constants
*/
#define SMALL_BLOCK_TYPE 0x00
#define BIG_BLOCK_TYPE 0x01
/*
* This define allows me to assign a function to a vtable without having the
* nasty warning about incompatible types.
*
* This is necessary because of the usage of implementation classes pointers
* as the first parameter of the interface functions instead of the pointer
* to the interface
*/
#define VTABLE_FUNC(a) ((void*)a)
/*
* These defines assume a hardcoded blocksize. The code will assert
* if the blocksize is different. Some changes will have to be done if it
* becomes the case.
*/
#define BIG_BLOCK_SIZE 0x200
#define COUNT_BBDEPOTINHEADER 109
#define LIMIT_TO_USE_SMALL_BLOCK 0x1000
/*
* These are signatures to detect the type of Document file.
*/
static const BYTE STORAGE_magic[8] ={0xd0,0xcf,0x11,0xe0,0xa1,0xb1,0x1a,0xe1};
static const BYTE STORAGE_oldmagic[8] ={0xd0,0xcf,0x11,0xe0,0x0e,0x11,0xfc,0x0d};
/*
* Forward declarations of all the structures used by the storage
* module.
*/
typedef struct Storage32BaseImpl Storage32BaseImpl;
typedef struct Storage32Impl Storage32Impl;
typedef struct Storage32InternalImpl Storage32InternalImpl;
typedef struct BlockChainStream BlockChainStream;
typedef struct SmallBlockChainStream SmallBlockChainStream;
typedef struct IEnumSTATSTGImpl IEnumSTATSTGImpl;
typedef struct StgProperty StgProperty;
typedef struct StgStreamImpl StgStreamImpl;
/*
* This utility structure is used to read/write the information in a storage
* property.
*/
struct StgProperty
{
WCHAR name[PROPERTY_NAME_MAX_LEN];
WORD sizeOfNameString;
BYTE propertyType;
BYTE blockType;
ULONG previousProperty;
ULONG nextProperty;
ULONG dirProperty;
GUID propertyUniqueID;
ULONG timeStampS1;
ULONG timeStampD1;
ULONG timeStampS2;
ULONG timeStampD2;
ULONG startingBlock;
ULARGE_INTEGER size;
};
/*************************************************************************
* Big Block File support
*
* The big block file is an abstraction of a flat file separated in
* same sized blocks. The implementation for the methods described in
* this section appear in stg_bigblockfile.c
*/
/*
* Declaration of the data structures
*/
typedef struct BigBlockFile BigBlockFile,*LPBIGBLOCKFILE;
typedef struct MappedPage MappedPage,*LPMAPPEDPAGE;
typedef struct BigBlock BigBlock,*LPBIGBLOCK;
struct BigBlockFile
{
ULARGE_INTEGER filesize;
ULONG blocksize;
HANDLE32 hfile;
HANDLE32 hfilemap;
MappedPage *headmap_ro;
MappedPage *headmap_w;
BigBlock *headblock;
};
/*
* Declaration of the functions used to manipulate the BigBlockFile
* data structure.
*/
BigBlockFile* BIGBLOCKFILE_Construct(HANDLE32 hFile, ULONG blocksize);
void BIGBLOCKFILE_Destructor(LPBIGBLOCKFILE This);
void* BIGBLOCKFILE_GetBigBlock(LPBIGBLOCKFILE This, ULONG index);
void* BIGBLOCKFILE_GetROBigBlock(LPBIGBLOCKFILE This, ULONG index);
void BIGBLOCKFILE_ReleaseBigBlock(LPBIGBLOCKFILE This, void *pBlock);
void BIGBLOCKFILE_SetSize(LPBIGBLOCKFILE This, ULARGE_INTEGER newSize);
ULARGE_INTEGER BIGBLOCKFILE_GetSize(LPBIGBLOCKFILE This);
/****************************************************************************
* Storage32BaseImpl definitions.
*
* This stucture defines the base information contained in all implementations
* of IStorage32 contained in this filee storage implementation.
*
* In OOP terms, this is the base class for all the IStorage32 implementations
* contained in this file.
*/
struct Storage32BaseImpl
{
ICOM_VTABLE(IStorage32)* lpvtbl; /* Needs to be the first item in the stuct
* since we want to cast this in a Storage32 pointer */
/*
* Reference count of this object
*/
ULONG ref;
/*
* Ancestor storage (top level)
*/
Storage32Impl* ancestorStorage;
/*
* Index of the property for the root of
* this storage
*/
ULONG rootPropertySetIndex;
/*
* virtual Destructor method.
*/
void (*v_destructor)(Storage32BaseImpl*);
};
/*
* Prototypes for the methods of the Storage32BaseImpl class.
*/
HRESULT WINAPI Storage32BaseImpl_QueryInterface(
Storage32BaseImpl* This,
REFIID riid,
void** ppvObject);
ULONG WINAPI Storage32BaseImpl_AddRef(
Storage32BaseImpl* This);
ULONG WINAPI Storage32BaseImpl_Release(
Storage32BaseImpl* This);
HRESULT WINAPI Storage32BaseImpl_OpenStream(
Storage32BaseImpl* This,
const OLECHAR32* pwcsName, /* [string][in] */
void* reserved1, /* [unique][in] */
DWORD grfMode, /* [in] */
DWORD reserved2, /* [in] */
IStream32** ppstm); /* [out] */
HRESULT WINAPI Storage32BaseImpl_OpenStorage(
Storage32BaseImpl* This,
const OLECHAR32* pwcsName, /* [string][unique][in] */
IStorage32* pstgPriority, /* [unique][in] */
DWORD grfMode, /* [in] */
SNB32 snbExclude, /* [unique][in] */
DWORD reserved, /* [in] */
IStorage32** ppstg); /* [out] */
HRESULT WINAPI Storage32BaseImpl_EnumElements(
Storage32BaseImpl* This,
DWORD reserved1, /* [in] */
void* reserved2, /* [size_is][unique][in] */
DWORD reserved3, /* [in] */
IEnumSTATSTG** ppenum); /* [out] */
HRESULT WINAPI Storage32BaseImpl_Stat(
Storage32BaseImpl* This,
STATSTG* pstatstg, /* [out] */
DWORD grfStatFlag); /* [in] */
HRESULT WINAPI Storage32BaseImpl_RenameElement(
Storage32BaseImpl* This,
const OLECHAR32* pwcsOldName, /* [string][in] */
const OLECHAR32* pwcsNewName); /* [string][in] */
HRESULT WINAPI Storage32BaseImpl_CreateStream(
Storage32BaseImpl* This,
const OLECHAR32* pwcsName, /* [string][in] */
DWORD grfMode, /* [in] */
DWORD reserved1, /* [in] */
DWORD reserved2, /* [in] */
IStream32** ppstm); /* [out] */
HRESULT WINAPI Storage32BaseImpl_SetClass(
Storage32BaseImpl* This,
REFCLSID clsid); /* [in] */
/****************************************************************************
* Storage32Impl definitions.
*
* This implementation of the IStorage32 interface represents a root
* storage. Basically, a document file.
*/
struct Storage32Impl
{
ICOM_VTABLE(IStorage32) *lpvtbl; /* Needs to be the first item in the stuct
* since we want to cast this in a Storage32 pointer */
/*
* Declare the member of the Storage32BaseImpl class to allow
* casting as a Storage32BaseImpl
*/
ULONG ref;
struct Storage32Impl* ancestorStorage;
ULONG rootPropertySetIndex;
void (*v_destructor)(struct Storage32Impl*);
/*
* The following data members are specific to the Storage32Impl
* class
*/
HANDLE32 hFile; /* Physical support for the Docfile */
/*
* File header
*/
WORD bigBlockSizeBits;
WORD smallBlockSizeBits;
ULONG bigBlockSize;
ULONG smallBlockSize;
ULONG bigBlockDepotCount;
ULONG rootStartBlock;
ULONG smallBlockDepotStart;
ULONG extBigBlockDepotStart;
ULONG extBigBlockDepotCount;
ULONG bigBlockDepotStart[COUNT_BBDEPOTINHEADER];
/*
* Abstraction of the big block chains for the chains of the header.
*/
BlockChainStream* rootBlockChain;
BlockChainStream* smallBlockDepotChain;
BlockChainStream* smallBlockRootChain;
/*
* Pointer to the big block file abstraction
*/
BigBlockFile* bigBlockFile;
};
/*
* Method declaration for the Storage32Impl class
*/
HRESULT WINAPI Storage32Impl_CreateStorage(
Storage32Impl* This,
const OLECHAR32* pwcsName, /* [string][in] */
DWORD grfMode, /* [in] */
DWORD dwStgFmt, /* [in] */
DWORD reserved2, /* [in] */
IStorage32** ppstg); /* [out] */
HRESULT WINAPI Storage32Impl_CopyTo(
Storage32Impl* This,
DWORD ciidExclude, /* [in] */
const IID* rgiidExclude, /* [size_is][unique][in] */
SNB32 snbExclude, /* [unique][in] */
IStorage32* pstgDest); /* [unique][in] */
HRESULT WINAPI Storage32Impl_MoveElementTo(
Storage32Impl* This,
const OLECHAR32* pwcsName, /* [string][in] */
IStorage32* pstgDest, /* [unique][in] */
const OLECHAR32* pwcsNewName, /* [string][in] */
DWORD grfFlags); /* [in] */
HRESULT WINAPI Storage32Impl_Commit(
Storage32Impl* This,
DWORD grfCommitFlags); /* [in] */
HRESULT WINAPI Storage32Impl_Revert(
Storage32Impl* This);
HRESULT WINAPI Storage32Impl_DestroyElement(
Storage32Impl* This,
const OLECHAR32* pwcsName); /* [string][in] */
HRESULT WINAPI Storage32Impl_SetElementTimes(
Storage32Impl* This,
const OLECHAR32* pwcsName, /* [string][in] */
const FILETIME* pctime, /* [in] */
const FILETIME* patime, /* [in] */
const FILETIME* pmtime); /* [in] */
HRESULT WINAPI Storage32Impl_SetStateBits(
Storage32Impl* This,
DWORD grfStateBits, /* [in] */
DWORD grfMask); /* [in] */
void Storage32Impl_Destroy(
Storage32Impl* This);
HRESULT Storage32Impl_Construct(
Storage32Impl* This,
HANDLE32 hFile,
DWORD openFlags);
BOOL32 Storage32Impl_ReadBigBlock(
Storage32Impl* This,
ULONG blockIndex,
void* buffer);
BOOL32 Storage32Impl_WriteBigBlock(
Storage32Impl* This,
ULONG blockIndex,
void* buffer);
void* Storage32Impl_GetROBigBlock(
Storage32Impl* This,
ULONG blockIndex);
void* Storage32Impl_GetBigBlock(
Storage32Impl* This,
ULONG blockIndex);
void Storage32Impl_ReleaseBigBlock(
Storage32Impl* This,
void* pBigBlock);
ULONG Storage32Impl_GetNextFreeBigBlock(
Storage32Impl* This);
void Storage32Impl_FreeBigBlock(
Storage32Impl* This,
ULONG blockIndex);
ULONG Storage32Impl_GetNextBlockInChain(
Storage32Impl* This,
ULONG blockIndex);
void Storage32Impl_SetNextBlockInChain(
Storage32Impl* This,
ULONG blockIndex,
ULONG nextBlock);
HRESULT Storage32Impl_LoadFileHeader(
Storage32Impl* This);
void Storage32Impl_SaveFileHeader(
Storage32Impl* This);
BOOL32 Storage32Impl_ReadProperty(
Storage32Impl* This,
ULONG index,
StgProperty* buffer);
BOOL32 Storage32Impl_WriteProperty(
Storage32Impl* This,
ULONG index,
StgProperty* buffer);
/****************************************************************************
* Storage32InternalImpl definitions.
*
* Definition of the implementation structure for the IStorage32 interface.
* This one implements the IStorage32 interface for storage that are
* inside another storage.
*/
struct Storage32InternalImpl
{
ICOM_VTABLE(IStorage32) *lpvtbl; /* Needs to be the first item in the stuct
* since we want to cast this in a Storage32 pointer */
/*
* Declare the member of the Storage32BaseImpl class to allow
* casting as a Storage32BaseImpl
*/
ULONG ref;
struct Storage32Impl* ancestorStorage;
ULONG rootPropertySetIndex;
void (*v_destructor)(struct Storage32InternalImpl*);
/*
* There is no specific data for this class.
*/
};
/*
* Method definitions for the Storage32InternalImpl class.
*/
Storage32InternalImpl* Storage32InternalImpl_Construct(
Storage32Impl* ancestorStorage,
ULONG rootTropertyIndex);
void Storage32InternalImpl_Destroy(
Storage32InternalImpl* This);
HRESULT WINAPI Storage32InternalImpl_Commit(
Storage32InternalImpl* This,
DWORD grfCommitFlags); /* [in] */
HRESULT WINAPI Storage32InternalImpl_Revert(
Storage32InternalImpl* This);
/****************************************************************************
* IEnumSTATSTGImpl definitions.
*
* Definition of the implementation structure for the IEnumSTATSTGImpl interface.
* This class allows iterating through the content of a storage and to find
* specific items inside it.
*/
struct IEnumSTATSTGImpl
{
ICOM_VTABLE(IEnumSTATSTG) *lpvtbl; /* Needs to be the first item in the stuct
* since we want to cast this in a IEnumSTATSTG pointer */
ULONG ref; /* Reference count */
Storage32Impl* parentStorage; /* Reference to the parent storage */
ULONG firstPropertyNode; /* Index of the root of the storage to enumerate */
/*
* The current implementation of the IEnumSTATSTGImpl class uses a stack
* to walk the property sets to get the content of a storage. This stack
* is implemented by the following 3 data members
*/
ULONG stackSize;
ULONG stackMaxSize;
ULONG* stackToVisit;
#define ENUMSTATSGT_SIZE_INCREMENT 10
};
/*
* Method definitions for the IEnumSTATSTGImpl class.
*/
HRESULT WINAPI IEnumSTATSTGImpl_QueryInterface(
IEnumSTATSTGImpl* This,
REFIID riid,
void** ppvObject);
ULONG WINAPI IEnumSTATSTGImpl_AddRef(
IEnumSTATSTGImpl* This);
ULONG WINAPI IEnumSTATSTGImpl_Release(
IEnumSTATSTGImpl* This);
HRESULT WINAPI IEnumSTATSTGImpl_Next(
IEnumSTATSTGImpl* This,
ULONG celt,
STATSTG* rgelt,
ULONG* pceltFetched);
HRESULT WINAPI IEnumSTATSTGImpl_Skip(
IEnumSTATSTGImpl* This,
ULONG celt);
HRESULT WINAPI IEnumSTATSTGImpl_Reset(
IEnumSTATSTGImpl* This);
HRESULT WINAPI IEnumSTATSTGImpl_Clone(
IEnumSTATSTGImpl* This,
IEnumSTATSTG** ppenum);
IEnumSTATSTGImpl* IEnumSTATSTGImpl_Construct(
Storage32Impl* This,
ULONG firstPropertyNode);
void IEnumSTATSTGImpl_Destroy(
IEnumSTATSTGImpl* This);
void IEnumSTATSTGImpl_PushSearchNode(
IEnumSTATSTGImpl* This,
ULONG nodeToPush);
ULONG IEnumSTATSTGImpl_PopSearchNode(
IEnumSTATSTGImpl* This,
BOOL32 remove);
ULONG IEnumSTATSTGImpl_FindProperty(
IEnumSTATSTGImpl* This,
const OLECHAR32* lpszPropName,
StgProperty* buffer);
INT32 IEnumSTATSTGImpl_FindParentProperty(
IEnumSTATSTGImpl *This,
ULONG childProperty,
StgProperty *currentProperty,
ULONG *propertyId);
/****************************************************************************
* StgStreamImpl definitions.
*
* This class imlements the IStream32 inteface and represents a stream
* located inside a storage object.
*/
struct StgStreamImpl
{
ICOM_VTABLE(IStream32) *lpvtbl; /* Needs to be the first item in the stuct
* since we want to cast this in a IStream pointer */
/*
* Reference count
*/
ULONG ref;
/*
* Storage that is the parent(owner) of the stream
*/
Storage32BaseImpl* parentStorage;
/*
* Index of the property that owns (points to) this stream.
*/
ULONG ownerProperty;
/*
* Helper variable that contains the size of the stream
*/
ULARGE_INTEGER streamSize;
/*
* This is the current position of the cursor in the stream
*/
ULARGE_INTEGER currentPosition;
/*
* The information in the stream is represented by a chain of small blocks
* or a chain of large blocks. Depending on the case, one of the two
* following variabled points to that information.
*/
BlockChainStream* bigBlockChain;
SmallBlockChainStream* smallBlockChain;
};
/*
* Method definition for the StgStreamImpl class.
*/
StgStreamImpl* StgStreamImpl_Construct(
Storage32BaseImpl* parentStorage,
ULONG ownerProperty);
void StgStreamImpl_Destroy(
StgStreamImpl* This);
void StgStreamImpl_OpenBlockChain(
StgStreamImpl* This);
HRESULT WINAPI StgStreamImpl_QueryInterface(
StgStreamImpl* This,
REFIID riid, /* [in] */
void** ppvObject); /* [iid_is][out] */
ULONG WINAPI StgStreamImpl_AddRef(
StgStreamImpl* This);
ULONG WINAPI StgStreamImpl_Release(
StgStreamImpl* This);
HRESULT WINAPI StgStreamImpl_Read(
StgStreamImpl* This,
void* pv, /* [length_is][size_is][out] */
ULONG cb, /* [in] */
ULONG* pcbRead); /* [out] */
HRESULT WINAPI StgStreamImpl_Write(
StgStreamImpl* This,
const void* pv, /* [size_is][in] */
ULONG cb, /* [in] */
ULONG* pcbWritten); /* [out] */
HRESULT WINAPI StgStreamImpl_Seek(
StgStreamImpl* This,
LARGE_INTEGER dlibMove, /* [in] */
DWORD dwOrigin, /* [in] */
ULARGE_INTEGER* plibNewPosition); /* [out] */
HRESULT WINAPI StgStreamImpl_SetSize(
StgStreamImpl* This,
ULARGE_INTEGER libNewSize); /* [in] */
HRESULT WINAPI StgStreamImpl_CopyTo(
StgStreamImpl* This,
IStream32* pstm, /* [unique][in] */
ULARGE_INTEGER cb, /* [in] */
ULARGE_INTEGER* pcbRead, /* [out] */
ULARGE_INTEGER* pcbWritten); /* [out] */
HRESULT WINAPI StgStreamImpl_Commit(
StgStreamImpl* This,
DWORD grfCommitFlags); /* [in] */
HRESULT WINAPI StgStreamImpl_Revert(
StgStreamImpl* This);
HRESULT WINAPI StgStreamImpl_LockRegion(
StgStreamImpl* This,
ULARGE_INTEGER libOffset, /* [in] */
ULARGE_INTEGER cb, /* [in] */
DWORD dwLockType); /* [in] */
HRESULT WINAPI StgStreamImpl_UnlockRegion(
StgStreamImpl* This,
ULARGE_INTEGER libOffset, /* [in] */
ULARGE_INTEGER cb, /* [in] */
DWORD dwLockType); /* [in] */
HRESULT WINAPI StgStreamImpl_Stat(
StgStreamImpl* This,
STATSTG* pstatstg, /* [out] */
DWORD grfStatFlag); /* [in] */
HRESULT WINAPI StgStreamImpl_Clone(
StgStreamImpl* This,
IStream32** ppstm); /* [out] */
/********************************************************************************
* The StorageUtl_ functions are miscelaneous utility functions. Most of which are
* abstractions used to read values from file buffers without having to worry
* about bit order
*/
void StorageUtl_ReadWord(void* buffer, ULONG offset, WORD* value);
void StorageUtl_WriteWord(void* buffer, ULONG offset, WORD value);
void StorageUtl_ReadDWord(void* buffer, ULONG offset, DWORD* value);
void StorageUtl_WriteDWord(void* buffer, ULONG offset, DWORD value);
void StorageUtl_ReadGUID(void* buffer, ULONG offset, GUID* value);
void StorageUtl_WriteGUID(void* buffer, ULONG offset, GUID* value);
void StorageUtl_CopyPropertyToSTATSTG(STATSTG* destination,
StgProperty* source,
int statFlags);
/****************************************************************************
* BlockChainStream definitions.
*
* The BlockChainStream class is a utility class that is used to create an
* abstraction of the big block chains in the storage file.
*/
struct BlockChainStream
{
Storage32Impl* parentStorage;
ULONG* headOfStreamPlaceHolder;
ULONG ownerPropertyIndex;
};
/*
* Methods for the BlockChainStream class.
*/
BlockChainStream* BlockChainStream_Construct(
Storage32Impl* parentStorage,
ULONG* headOfStreamPlaceHolder,
ULONG propertyIndex);
void BlockChainStream_Destroy(
BlockChainStream* This);
ULONG BlockChainStream_GetHeadOfChain(
BlockChainStream* This);
BOOL32 BlockChainStream_ReadAt(
BlockChainStream* This,
ULARGE_INTEGER offset,
ULONG size,
void* buffer,
ULONG* bytesRead);
BOOL32 BlockChainStream_WriteAt(
BlockChainStream* This,
ULARGE_INTEGER offset,
ULONG size,
const void* buffer,
ULONG* bytesWritten);
BOOL32 BlockChainStream_SetSize(
BlockChainStream* This,
ULARGE_INTEGER newSize);
ULARGE_INTEGER BlockChainStream_GetSize(
BlockChainStream* This);
ULONG BlockChainStream_GetCount(
BlockChainStream* This);
/****************************************************************************
* SmallBlockChainStream definitions.
*
* The SmallBlockChainStream class is a utility class that is used to create an
* abstraction of the small block chains in the storage file.
*/
struct SmallBlockChainStream
{
Storage32Impl* parentStorage;
ULONG ownerPropertyIndex;
};
/*
* Methods of the SmallBlockChainStream class.
*/
SmallBlockChainStream* SmallBlockChainStream_Construct(
Storage32Impl* parentStorage,
ULONG propertyIndex);
void SmallBlockChainStream_Destroy(
SmallBlockChainStream* This);
ULONG SmallBlockChainStream_GetHeadOfChain(
SmallBlockChainStream* This);
ULONG SmallBlockChainStream_GetNextBlockInChain(
SmallBlockChainStream* This,
ULONG blockIndex);
void SmallBlockChainStream_SetNextBlockInChain(
SmallBlockChainStream* This,
ULONG blockIndex,
ULONG nextBlock);
void SmallBlockChainStream_FreeBlock(
SmallBlockChainStream* This,
ULONG blockIndex);
ULONG SmallBlockChainStream_GetNextFreeBlock(
SmallBlockChainStream* This);
BOOL32 SmallBlockChainStream_ReadAt(
SmallBlockChainStream* This,
ULARGE_INTEGER offset,
ULONG size,
void* buffer,
ULONG* bytesRead);
BOOL32 SmallBlockChainStream_WriteAt(
SmallBlockChainStream* This,
ULARGE_INTEGER offset,
ULONG size,
const void* buffer,
ULONG* bytesWritten);
BOOL32 SmallBlockChainStream_SetSize(
SmallBlockChainStream* This,
ULARGE_INTEGER newSize);
ULARGE_INTEGER SmallBlockChainStream_GetSize(
SmallBlockChainStream* This);
ULONG SmallBlockChainStream_GetCount(
SmallBlockChainStream* This);
#endif __STORAGE32_H__

2
relay32/ole32.spec
View File

@ -158,7 +158,7 @@ type win32
155 stub UtConvertDvtd32toDvtd16
156 stub UtGetDvtd16Info
157 stub UtGetDvtd32Info
158 stub WriteClassStg
158 stdcall WriteClassStg(ptr ptr) WriteClassStg32
159 stub WriteClassStm
160 stub WriteFmtUserTypeStg
161 stub WriteOleStg