2 * Compound Storage (32 bit version)
4 * Implemented using the documentation of the LAOLA project at
5 * <URL:http://wwwwbs.cs.tu-berlin.de/~schwartz/pmh/index.html>
6 * (Thanks to Martin Schwartz <schwartz@cs.tu-berlin.de>)
8 * This include file contains definitions of types and function
9 * prototypes that are used in the many files implementing the
10 * storage functionality
12 * Copyright 1998,1999 Francis Beaudet
13 * Copyright 1998,1999 Thuy Nguyen
15 * This library is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU Lesser General Public
17 * License as published by the Free Software Foundation; either
18 * version 2.1 of the License, or (at your option) any later version.
20 * This library is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 * Lesser General Public License for more details.
25 * You should have received a copy of the GNU Lesser General Public
26 * License along with this library; if not, write to the Free Software
27 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
29 #ifndef __STORAGE32_H__
30 #define __STORAGE32_H__
40 #include "wine/list.h"
43 * Definitions for the file format offsets.
45 static const ULONG OFFSET_BIGBLOCKSIZEBITS
= 0x0000001e;
46 static const ULONG OFFSET_SMALLBLOCKSIZEBITS
= 0x00000020;
47 static const ULONG OFFSET_BBDEPOTCOUNT
= 0x0000002C;
48 static const ULONG OFFSET_ROOTSTARTBLOCK
= 0x00000030;
49 static const ULONG OFFSET_SBDEPOTSTART
= 0x0000003C;
50 static const ULONG OFFSET_SBDEPOTCOUNT
= 0x00000040;
51 static const ULONG OFFSET_EXTBBDEPOTSTART
= 0x00000044;
52 static const ULONG OFFSET_EXTBBDEPOTCOUNT
= 0x00000048;
53 static const ULONG OFFSET_BBDEPOTSTART
= 0x0000004C;
54 static const ULONG OFFSET_PS_NAME
= 0x00000000;
55 static const ULONG OFFSET_PS_NAMELENGTH
= 0x00000040;
56 static const ULONG OFFSET_PS_PROPERTYTYPE
= 0x00000042;
57 static const ULONG OFFSET_PS_PREVIOUSPROP
= 0x00000044;
58 static const ULONG OFFSET_PS_NEXTPROP
= 0x00000048;
59 static const ULONG OFFSET_PS_DIRPROP
= 0x0000004C;
60 static const ULONG OFFSET_PS_GUID
= 0x00000050;
61 static const ULONG OFFSET_PS_TSS1
= 0x00000064;
62 static const ULONG OFFSET_PS_TSD1
= 0x00000068;
63 static const ULONG OFFSET_PS_TSS2
= 0x0000006C;
64 static const ULONG OFFSET_PS_TSD2
= 0x00000070;
65 static const ULONG OFFSET_PS_STARTBLOCK
= 0x00000074;
66 static const ULONG OFFSET_PS_SIZE
= 0x00000078;
67 static const WORD DEF_BIG_BLOCK_SIZE_BITS
= 0x0009;
68 static const WORD DEF_SMALL_BLOCK_SIZE_BITS
= 0x0006;
69 static const WORD DEF_BIG_BLOCK_SIZE
= 0x0200;
70 static const WORD DEF_SMALL_BLOCK_SIZE
= 0x0040;
71 static const ULONG BLOCK_EXTBBDEPOT
= 0xFFFFFFFC;
72 static const ULONG BLOCK_SPECIAL
= 0xFFFFFFFD;
73 static const ULONG BLOCK_END_OF_CHAIN
= 0xFFFFFFFE;
74 static const ULONG BLOCK_UNUSED
= 0xFFFFFFFF;
75 static const ULONG PROPERTY_NULL
= 0xFFFFFFFF;
77 #define PROPERTY_NAME_MAX_LEN 0x20
78 #define PROPERTY_NAME_BUFFER_LEN 0x40
80 #define PROPSET_BLOCK_SIZE 0x00000080
83 * Property type of relation
85 #define PROPERTY_RELATION_PREVIOUS 0
86 #define PROPERTY_RELATION_NEXT 1
87 #define PROPERTY_RELATION_DIR 2
90 * Property type constants
92 #define PROPTYPE_STORAGE 0x01
93 #define PROPTYPE_STREAM 0x02
94 #define PROPTYPE_ROOT 0x05
97 * These defines assume a hardcoded blocksize. The code will assert
98 * if the blocksize is different. Some changes will have to be done if it
101 #define BIG_BLOCK_SIZE 0x200
102 #define COUNT_BBDEPOTINHEADER 109
103 #define LIMIT_TO_USE_SMALL_BLOCK 0x1000
104 #define NUM_BLOCKS_PER_DEPOT_BLOCK 128
106 #define STGM_ACCESS_MODE(stgm) ((stgm)&0x0000f)
107 #define STGM_SHARE_MODE(stgm) ((stgm)&0x000f0)
108 #define STGM_CREATE_MODE(stgm) ((stgm)&0x0f000)
110 #define STGM_KNOWN_FLAGS (0xf0ff | \
111 STGM_TRANSACTED | STGM_CONVERT | STGM_PRIORITY | STGM_NOSCRATCH | \
112 STGM_NOSNAPSHOT | STGM_DIRECT_SWMR | STGM_DELETEONRELEASE | STGM_SIMPLE)
115 * These are signatures to detect the type of Document file.
117 static const BYTE STORAGE_magic
[8] ={0xd0,0xcf,0x11,0xe0,0xa1,0xb1,0x1a,0xe1};
118 static const BYTE STORAGE_oldmagic
[8] ={0xd0,0xcf,0x11,0xe0,0x0e,0x11,0xfc,0x0d};
121 * Forward declarations of all the structures used by the storage
124 typedef struct StorageBaseImpl StorageBaseImpl
;
125 typedef struct StorageImpl StorageImpl
;
126 typedef struct StorageInternalImpl StorageInternalImpl
;
127 typedef struct BlockChainStream BlockChainStream
;
128 typedef struct SmallBlockChainStream SmallBlockChainStream
;
129 typedef struct IEnumSTATSTGImpl IEnumSTATSTGImpl
;
130 typedef struct StgProperty StgProperty
;
131 typedef struct StgStreamImpl StgStreamImpl
;
134 * This utility structure is used to read/write the information in a storage
139 WCHAR name
[PROPERTY_NAME_MAX_LEN
];
140 WORD sizeOfNameString
;
142 ULONG previousProperty
;
145 GUID propertyUniqueID
;
154 /*************************************************************************
155 * Big Block File support
157 * The big block file is an abstraction of a flat file separated in
158 * same sized blocks. The implementation for the methods described in
159 * this section appear in stg_bigblockfile.c
163 * Declaration of the data structures
165 typedef struct BigBlockFile BigBlockFile
,*LPBIGBLOCKFILE
;
166 typedef struct MappedPage MappedPage
,*LPMAPPEDPAGE
;
171 ULARGE_INTEGER filesize
;
177 MappedPage
*victimhead
, *victimtail
;
178 ULONG num_victim_pages
;
185 * Declaration of the functions used to manipulate the BigBlockFile
188 BigBlockFile
* BIGBLOCKFILE_Construct(HANDLE hFile
,
193 void BIGBLOCKFILE_Destructor(LPBIGBLOCKFILE This
);
194 void* BIGBLOCKFILE_GetBigBlock(LPBIGBLOCKFILE This
, ULONG index
);
195 void* BIGBLOCKFILE_GetROBigBlock(LPBIGBLOCKFILE This
, ULONG index
);
196 void BIGBLOCKFILE_ReleaseBigBlock(LPBIGBLOCKFILE This
, void *pBlock
);
197 void BIGBLOCKFILE_SetSize(LPBIGBLOCKFILE This
, ULARGE_INTEGER newSize
);
198 ULARGE_INTEGER
BIGBLOCKFILE_GetSize(LPBIGBLOCKFILE This
);
200 /*************************************************************************
201 * Ole Convert support
204 void OLECONVERT_CreateOleStream(LPSTORAGE pStorage
);
205 HRESULT
OLECONVERT_CreateCompObjStream(LPSTORAGE pStorage
, LPCSTR strOleTypeName
);
207 /****************************************************************************
208 * Storage32BaseImpl definitions.
210 * This structure defines the base information contained in all implementations
211 * of IStorage32 contained in this file storage implementation.
213 * In OOP terms, this is the base class for all the IStorage32 implementations
214 * contained in this file.
216 struct StorageBaseImpl
218 const IStorageVtbl
*lpVtbl
; /* Needs to be the first item in the struct
219 * since we want to cast this in a Storage32 pointer */
221 const IPropertySetStorageVtbl
*pssVtbl
; /* interface for adding a properties stream */
224 * Stream tracking list
227 struct list strmHead
;
230 * Reference count of this object
235 * Ancestor storage (top level)
237 StorageImpl
* ancestorStorage
;
240 * Index of the property for the root of
243 ULONG rootPropertySetIndex
;
246 * virtual Destructor method.
248 void (*v_destructor
)(StorageBaseImpl
*);
251 * flags that this storage was opened or created with
256 /****************************************************************************
257 * StorageBaseImpl stream list handlers
260 void StorageBaseImpl_AddStream(StorageBaseImpl
* stg
, StgStreamImpl
* strm
);
261 void StorageBaseImpl_RemoveStream(StorageBaseImpl
* stg
, StgStreamImpl
* strm
);
262 void StorageBaseImpl_DeleteAll(StorageBaseImpl
* stg
);
264 /****************************************************************************
265 * Storage32Impl definitions.
267 * This implementation of the IStorage32 interface represents a root
268 * storage. Basically, a document file.
272 struct StorageBaseImpl base
;
275 * The following data members are specific to the Storage32Impl
278 HANDLE hFile
; /* Physical support for the Docfile */
279 LPOLESTR pwcsName
; /* Full path of the document file */
281 /* FIXME: should this be in Storage32BaseImpl ? */
282 WCHAR filename
[PROPERTY_NAME_BUFFER_LEN
];
287 WORD bigBlockSizeBits
;
288 WORD smallBlockSizeBits
;
290 ULONG smallBlockSize
;
291 ULONG bigBlockDepotCount
;
292 ULONG rootStartBlock
;
293 ULONG smallBlockDepotStart
;
294 ULONG extBigBlockDepotStart
;
295 ULONG extBigBlockDepotCount
;
296 ULONG bigBlockDepotStart
[COUNT_BBDEPOTINHEADER
];
298 ULONG blockDepotCached
[NUM_BLOCKS_PER_DEPOT_BLOCK
];
299 ULONG indexBlockDepotCached
;
303 * Abstraction of the big block chains for the chains of the header.
305 BlockChainStream
* rootBlockChain
;
306 BlockChainStream
* smallBlockDepotChain
;
307 BlockChainStream
* smallBlockRootChain
;
310 * Pointer to the big block file abstraction
312 BigBlockFile
* bigBlockFile
;
315 void StorageImpl_Destroy(
316 StorageBaseImpl
* This
);
318 HRESULT
StorageImpl_Construct(
327 BOOL
StorageImpl_ReadBigBlock(
332 BOOL
StorageImpl_WriteBigBlock(
337 void* StorageImpl_GetROBigBlock(
341 void* StorageImpl_GetBigBlock(
345 void StorageImpl_ReleaseBigBlock(
349 ULONG
StorageImpl_GetNextFreeBigBlock(
352 void StorageImpl_FreeBigBlock(
356 HRESULT
StorageImpl_GetNextBlockInChain(
359 ULONG
* nextBlockIndex
);
361 void StorageImpl_SetNextBlockInChain(
366 HRESULT
StorageImpl_LoadFileHeader(
369 void StorageImpl_SaveFileHeader(
372 BOOL
StorageImpl_ReadProperty(
375 StgProperty
* buffer
);
377 BOOL
StorageImpl_WriteProperty(
380 StgProperty
* buffer
);
382 BlockChainStream
* Storage32Impl_SmallBlocksToBigBlocks(
384 SmallBlockChainStream
** ppsbChain
);
386 ULONG
Storage32Impl_GetNextExtendedBlock(StorageImpl
* This
,
389 void Storage32Impl_AddBlockDepot(StorageImpl
* This
,
392 ULONG
Storage32Impl_AddExtBlockDepot(StorageImpl
* This
);
394 ULONG
Storage32Impl_GetExtDepotBlock(StorageImpl
* This
,
397 void Storage32Impl_SetExtDepotBlock(StorageImpl
* This
,
400 /****************************************************************************
401 * Storage32InternalImpl definitions.
403 * Definition of the implementation structure for the IStorage32 interface.
404 * This one implements the IStorage32 interface for storage that are
405 * inside another storage.
407 struct StorageInternalImpl
409 struct StorageBaseImpl base
;
412 * There is no specific data for this class.
417 * Method definitions for the Storage32InternalImpl class.
419 StorageInternalImpl
* StorageInternalImpl_Construct(
420 StorageImpl
* ancestorStorage
,
422 ULONG rootTropertyIndex
);
424 void StorageInternalImpl_Destroy(
425 StorageBaseImpl
* This
);
427 HRESULT WINAPI
StorageInternalImpl_Commit(
429 DWORD grfCommitFlags
); /* [in] */
431 HRESULT WINAPI
StorageInternalImpl_Revert(
435 /****************************************************************************
436 * IEnumSTATSTGImpl definitions.
438 * Definition of the implementation structure for the IEnumSTATSTGImpl interface.
439 * This class allows iterating through the content of a storage and to find
440 * specific items inside it.
442 struct IEnumSTATSTGImpl
444 const IEnumSTATSTGVtbl
*lpVtbl
; /* Needs to be the first item in the struct
445 * since we want to cast this in an IEnumSTATSTG pointer */
447 LONG ref
; /* Reference count */
448 StorageImpl
* parentStorage
; /* Reference to the parent storage */
449 ULONG firstPropertyNode
; /* Index of the root of the storage to enumerate */
452 * The current implementation of the IEnumSTATSTGImpl class uses a stack
453 * to walk the property sets to get the content of a storage. This stack
454 * is implemented by the following 3 data members
460 #define ENUMSTATSGT_SIZE_INCREMENT 10
463 IEnumSTATSTGImpl
* IEnumSTATSTGImpl_Construct(
465 ULONG firstPropertyNode
);
467 void IEnumSTATSTGImpl_Destroy(
468 IEnumSTATSTGImpl
* This
);
470 void IEnumSTATSTGImpl_PushSearchNode(
471 IEnumSTATSTGImpl
* This
,
474 ULONG
IEnumSTATSTGImpl_PopSearchNode(
475 IEnumSTATSTGImpl
* This
,
478 ULONG
IEnumSTATSTGImpl_FindProperty(
479 IEnumSTATSTGImpl
* This
,
480 const OLECHAR
* lpszPropName
,
481 StgProperty
* buffer
);
483 INT
IEnumSTATSTGImpl_FindParentProperty(
484 IEnumSTATSTGImpl
*This
,
486 StgProperty
*currentProperty
,
490 /****************************************************************************
491 * StgStreamImpl definitions.
493 * This class imlements the IStream32 inteface and represents a stream
494 * located inside a storage object.
498 const IStreamVtbl
*lpVtbl
; /* Needs to be the first item in the struct
499 * since we want to cast this to an IStream pointer */
502 * We are an entry in the storage object's stream handler list
505 struct list StrmListEntry
;
513 * Storage that is the parent(owner) of the stream
515 StorageBaseImpl
* parentStorage
;
518 * Access mode of this stream.
523 * Index of the property that owns (points to) this stream.
528 * Helper variable that contains the size of the stream
530 ULARGE_INTEGER streamSize
;
533 * This is the current position of the cursor in the stream
535 ULARGE_INTEGER currentPosition
;
538 * The information in the stream is represented by a chain of small blocks
539 * or a chain of large blocks. Depending on the case, one of the two
540 * following variabled points to that information.
542 BlockChainStream
* bigBlockChain
;
543 SmallBlockChainStream
* smallBlockChain
;
547 * Method definition for the StgStreamImpl class.
549 StgStreamImpl
* StgStreamImpl_Construct(
550 StorageBaseImpl
* parentStorage
,
552 ULONG ownerProperty
);
555 /******************************************************************************
556 * Endian conversion macros
558 #ifdef WORDS_BIGENDIAN
560 #define htole32(x) RtlUlongByteSwap(x)
561 #define htole16(x) RtlUshortByteSwap(x)
562 #define le32toh(x) RtlUlongByteSwap(x)
563 #define le16toh(x) RtlUshortByteSwap(x)
567 #define htole32(x) (x)
568 #define htole16(x) (x)
569 #define le32toh(x) (x)
570 #define le16toh(x) (x)
574 /******************************************************************************
575 * The StorageUtl_ functions are miscellaneous utility functions. Most of which
576 * are abstractions used to read values from file buffers without having to
577 * worry about bit order
579 void StorageUtl_ReadWord(const BYTE
* buffer
, ULONG offset
, WORD
* value
);
580 void StorageUtl_WriteWord(BYTE
* buffer
, ULONG offset
, WORD value
);
581 void StorageUtl_ReadDWord(const BYTE
* buffer
, ULONG offset
, DWORD
* value
);
582 void StorageUtl_WriteDWord(BYTE
* buffer
, ULONG offset
, DWORD value
);
583 void StorageUtl_ReadULargeInteger(const BYTE
* buffer
, ULONG offset
,
584 ULARGE_INTEGER
* value
);
585 void StorageUtl_WriteULargeInteger(BYTE
* buffer
, ULONG offset
,
586 const ULARGE_INTEGER
*value
);
587 void StorageUtl_ReadGUID(const BYTE
* buffer
, ULONG offset
, GUID
* value
);
588 void StorageUtl_WriteGUID(BYTE
* buffer
, ULONG offset
, const GUID
* value
);
589 void StorageUtl_CopyPropertyToSTATSTG(STATSTG
* destination
,
593 /****************************************************************************
594 * BlockChainStream definitions.
596 * The BlockChainStream class is a utility class that is used to create an
597 * abstraction of the big block chains in the storage file.
599 struct BlockChainStream
601 StorageImpl
* parentStorage
;
602 ULONG
* headOfStreamPlaceHolder
;
603 ULONG ownerPropertyIndex
;
604 ULONG lastBlockNoInSequence
;
605 ULONG lastBlockNoInSequenceIndex
;
611 * Methods for the BlockChainStream class.
613 BlockChainStream
* BlockChainStream_Construct(
614 StorageImpl
* parentStorage
,
615 ULONG
* headOfStreamPlaceHolder
,
616 ULONG propertyIndex
);
618 void BlockChainStream_Destroy(
619 BlockChainStream
* This
);
621 ULONG
BlockChainStream_GetHeadOfChain(
622 BlockChainStream
* This
);
624 BOOL
BlockChainStream_ReadAt(
625 BlockChainStream
* This
,
626 ULARGE_INTEGER offset
,
631 BOOL
BlockChainStream_WriteAt(
632 BlockChainStream
* This
,
633 ULARGE_INTEGER offset
,
636 ULONG
* bytesWritten
);
638 BOOL
BlockChainStream_SetSize(
639 BlockChainStream
* This
,
640 ULARGE_INTEGER newSize
);
642 ULARGE_INTEGER
BlockChainStream_GetSize(
643 BlockChainStream
* This
);
645 ULONG
BlockChainStream_GetCount(
646 BlockChainStream
* This
);
648 /****************************************************************************
649 * SmallBlockChainStream definitions.
651 * The SmallBlockChainStream class is a utility class that is used to create an
652 * abstraction of the small block chains in the storage file.
654 struct SmallBlockChainStream
656 StorageImpl
* parentStorage
;
657 ULONG ownerPropertyIndex
;
661 * Methods of the SmallBlockChainStream class.
663 SmallBlockChainStream
* SmallBlockChainStream_Construct(
664 StorageImpl
* parentStorage
,
665 ULONG propertyIndex
);
667 void SmallBlockChainStream_Destroy(
668 SmallBlockChainStream
* This
);
670 ULONG
SmallBlockChainStream_GetHeadOfChain(
671 SmallBlockChainStream
* This
);
673 HRESULT
SmallBlockChainStream_GetNextBlockInChain(
674 SmallBlockChainStream
* This
,
676 ULONG
* nextBlockIndex
);
678 void SmallBlockChainStream_SetNextBlockInChain(
679 SmallBlockChainStream
* This
,
683 void SmallBlockChainStream_FreeBlock(
684 SmallBlockChainStream
* This
,
687 ULONG
SmallBlockChainStream_GetNextFreeBlock(
688 SmallBlockChainStream
* This
);
690 HRESULT
SmallBlockChainStream_ReadAt(
691 SmallBlockChainStream
* This
,
692 ULARGE_INTEGER offset
,
697 BOOL
SmallBlockChainStream_WriteAt(
698 SmallBlockChainStream
* This
,
699 ULARGE_INTEGER offset
,
702 ULONG
* bytesWritten
);
704 BOOL
SmallBlockChainStream_SetSize(
705 SmallBlockChainStream
* This
,
706 ULARGE_INTEGER newSize
);
708 ULARGE_INTEGER
SmallBlockChainStream_GetSize(
709 SmallBlockChainStream
* This
);
711 ULONG
SmallBlockChainStream_GetCount(
712 SmallBlockChainStream
* This
);
715 #endif /* __STORAGE32_H__ */