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_STGTYPE
= 0x00000042;
57 static const ULONG OFFSET_PS_LEFTCHILD
= 0x00000044;
58 static const ULONG OFFSET_PS_RIGHTCHILD
= 0x00000048;
59 static const ULONG OFFSET_PS_DIRROOT
= 0x0000004C;
60 static const ULONG OFFSET_PS_GUID
= 0x00000050;
61 static const ULONG OFFSET_PS_CTIMELOW
= 0x00000064;
62 static const ULONG OFFSET_PS_CTIMEHIGH
= 0x00000068;
63 static const ULONG OFFSET_PS_MTIMELOW
= 0x0000006C;
64 static const ULONG OFFSET_PS_MTIMEHIGH
= 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 DIRENTRY_NULL
= 0xFFFFFFFF;
77 #define DIRENTRY_NAME_MAX_LEN 0x20
78 #define DIRENTRY_NAME_BUFFER_LEN 0x40
80 #define RAW_DIRENTRY_SIZE 0x00000080
83 * Type of child entry link
85 #define DIRENTRY_RELATION_PREVIOUS 0
86 #define DIRENTRY_RELATION_NEXT 1
87 #define DIRENTRY_RELATION_DIR 2
90 * type constant used in files for the root storage
92 #define STGTY_ROOT 0x05
95 * These defines assume a hardcoded blocksize. The code will assert
96 * if the blocksize is different. Some changes will have to be done if it
99 #define BIG_BLOCK_SIZE 0x200
100 #define COUNT_BBDEPOTINHEADER 109
101 #define LIMIT_TO_USE_SMALL_BLOCK 0x1000
102 #define NUM_BLOCKS_PER_DEPOT_BLOCK 128
104 #define STGM_ACCESS_MODE(stgm) ((stgm)&0x0000f)
105 #define STGM_SHARE_MODE(stgm) ((stgm)&0x000f0)
106 #define STGM_CREATE_MODE(stgm) ((stgm)&0x0f000)
108 #define STGM_KNOWN_FLAGS (0xf0ff | \
109 STGM_TRANSACTED | STGM_CONVERT | STGM_PRIORITY | STGM_NOSCRATCH | \
110 STGM_NOSNAPSHOT | STGM_DIRECT_SWMR | STGM_DELETEONRELEASE | STGM_SIMPLE)
113 * Forward declarations of all the structures used by the storage
116 typedef struct StorageBaseImpl StorageBaseImpl
;
117 typedef struct StorageBaseImplVtbl StorageBaseImplVtbl
;
118 typedef struct StorageImpl StorageImpl
;
119 typedef struct BlockChainStream BlockChainStream
;
120 typedef struct SmallBlockChainStream SmallBlockChainStream
;
121 typedef struct IEnumSTATSTGImpl IEnumSTATSTGImpl
;
122 typedef struct DirEntry DirEntry
;
123 typedef struct StgStreamImpl StgStreamImpl
;
126 * A reference to a directory entry in the file or a transacted cache.
128 typedef ULONG DirRef
;
131 * This utility structure is used to read/write the information in a directory
136 WCHAR name
[DIRENTRY_NAME_MAX_LEN
];
137 WORD sizeOfNameString
;
149 /*************************************************************************
150 * Big Block File support
152 * The big block file is an abstraction of a flat file separated in
153 * same sized blocks. The implementation for the methods described in
154 * this section appear in stg_bigblockfile.c
157 typedef struct BigBlockFile BigBlockFile
,*LPBIGBLOCKFILE
;
160 * Declaration of the functions used to manipulate the BigBlockFile
163 BigBlockFile
* BIGBLOCKFILE_Construct(HANDLE hFile
,
168 void BIGBLOCKFILE_Destructor(LPBIGBLOCKFILE This
);
169 HRESULT
BIGBLOCKFILE_EnsureExists(LPBIGBLOCKFILE This
, ULONG index
);
170 HRESULT
BIGBLOCKFILE_SetSize(LPBIGBLOCKFILE This
, ULARGE_INTEGER newSize
);
171 HRESULT
BIGBLOCKFILE_ReadAt(LPBIGBLOCKFILE This
, ULARGE_INTEGER offset
,
172 void* buffer
, ULONG size
, ULONG
* bytesRead
);
173 HRESULT
BIGBLOCKFILE_WriteAt(LPBIGBLOCKFILE This
, ULARGE_INTEGER offset
,
174 const void* buffer
, ULONG size
, ULONG
* bytesRead
);
176 /*************************************************************************
177 * Ole Convert support
180 void OLECONVERT_CreateOleStream(LPSTORAGE pStorage
);
181 HRESULT
OLECONVERT_CreateCompObjStream(LPSTORAGE pStorage
, LPCSTR strOleTypeName
);
184 /****************************************************************************
185 * Storage32BaseImpl definitions.
187 * This structure defines the base information contained in all implementations
188 * of IStorage32 contained in this file storage implementation.
190 * In OOP terms, this is the base class for all the IStorage32 implementations
191 * contained in this file.
193 struct StorageBaseImpl
195 const IStorageVtbl
*lpVtbl
; /* Needs to be the first item in the struct
196 * since we want to cast this in a Storage32 pointer */
198 const IPropertySetStorageVtbl
*pssVtbl
; /* interface for adding a properties stream */
201 * Stream tracking list
204 struct list strmHead
;
207 * Storage tracking list
209 struct list storageHead
;
212 * Reference count of this object
217 * Ancestor storage (top level)
219 StorageImpl
* ancestorStorage
;
222 * Index of the directory entry of this storage
224 DirRef storageDirEntry
;
229 const StorageBaseImplVtbl
*baseVtbl
;
232 * flags that this storage was opened or created with
237 * State bits appear to only be preserved while running. No in the stream
241 /* If set, this overrides the root storage name returned by IStorage_Stat */
242 WCHAR filename
[DIRENTRY_NAME_BUFFER_LEN
];
244 BOOL create
; /* Was the storage created or opened.
245 The behaviour of STGM_SIMPLE depends on this */
248 /* virtual methods for StorageBaseImpl objects */
249 struct StorageBaseImplVtbl
{
250 void (*Destroy
)(StorageBaseImpl
*);
253 static inline void StorageBaseImpl_Destroy(StorageBaseImpl
*This
)
255 This
->baseVtbl
->Destroy(This
);
258 /****************************************************************************
259 * StorageBaseImpl stream list handlers
262 void StorageBaseImpl_AddStream(StorageBaseImpl
* stg
, StgStreamImpl
* strm
);
263 void StorageBaseImpl_RemoveStream(StorageBaseImpl
* stg
, StgStreamImpl
* strm
);
265 /****************************************************************************
266 * Storage32Impl definitions.
268 * This implementation of the IStorage32 interface represents a root
269 * storage. Basically, a document file.
273 struct StorageBaseImpl base
;
276 * The following data members are specific to the Storage32Impl
279 HANDLE hFile
; /* Physical support for the Docfile */
280 LPOLESTR pwcsName
; /* Full path of the document file */
285 WORD bigBlockSizeBits
;
286 WORD smallBlockSizeBits
;
288 ULONG smallBlockSize
;
289 ULONG bigBlockDepotCount
;
290 ULONG rootStartBlock
;
291 ULONG smallBlockDepotStart
;
292 ULONG extBigBlockDepotStart
;
293 ULONG extBigBlockDepotCount
;
294 ULONG bigBlockDepotStart
[COUNT_BBDEPOTINHEADER
];
296 ULONG blockDepotCached
[NUM_BLOCKS_PER_DEPOT_BLOCK
];
297 ULONG indexBlockDepotCached
;
301 * Abstraction of the big block chains for the chains of the header.
303 BlockChainStream
* rootBlockChain
;
304 BlockChainStream
* smallBlockDepotChain
;
305 BlockChainStream
* smallBlockRootChain
;
308 * Pointer to the big block file abstraction
310 BigBlockFile
* bigBlockFile
;
313 HRESULT
StorageImpl_ReadRawDirEntry(
318 void UpdateRawDirEntry(
320 const DirEntry
*newData
);
322 HRESULT
StorageImpl_WriteRawDirEntry(
327 BOOL
StorageImpl_ReadDirEntry(
332 BOOL
StorageImpl_WriteDirEntry(
335 const DirEntry
* buffer
);
337 BlockChainStream
* Storage32Impl_SmallBlocksToBigBlocks(
339 SmallBlockChainStream
** ppsbChain
);
341 SmallBlockChainStream
* Storage32Impl_BigBlocksToSmallBlocks(
343 BlockChainStream
** ppbbChain
);
345 /****************************************************************************
346 * StgStreamImpl definitions.
348 * This class implements the IStream32 interface and represents a stream
349 * located inside a storage object.
353 const IStreamVtbl
*lpVtbl
; /* Needs to be the first item in the struct
354 * since we want to cast this to an IStream pointer */
357 * We are an entry in the storage object's stream handler list
360 struct list StrmListEntry
;
368 * Storage that is the parent(owner) of the stream
370 StorageBaseImpl
* parentStorage
;
373 * Access mode of this stream.
378 * Index of the directory entry that owns (points to) this stream.
383 * Helper variable that contains the size of the stream
385 ULARGE_INTEGER streamSize
;
388 * This is the current position of the cursor in the stream
390 ULARGE_INTEGER currentPosition
;
393 * The information in the stream is represented by a chain of small blocks
394 * or a chain of large blocks. Depending on the case, one of the two
395 * following variables points to that information.
397 BlockChainStream
* bigBlockChain
;
398 SmallBlockChainStream
* smallBlockChain
;
402 * Method definition for the StgStreamImpl class.
404 StgStreamImpl
* StgStreamImpl_Construct(
405 StorageBaseImpl
* parentStorage
,
410 /******************************************************************************
411 * Endian conversion macros
413 #ifdef WORDS_BIGENDIAN
415 #define htole32(x) RtlUlongByteSwap(x)
416 #define htole16(x) RtlUshortByteSwap(x)
417 #define lendian32toh(x) RtlUlongByteSwap(x)
418 #define lendian16toh(x) RtlUshortByteSwap(x)
422 #define htole32(x) (x)
423 #define htole16(x) (x)
424 #define lendian32toh(x) (x)
425 #define lendian16toh(x) (x)
429 /******************************************************************************
430 * The StorageUtl_ functions are miscellaneous utility functions. Most of which
431 * are abstractions used to read values from file buffers without having to
432 * worry about bit order
434 void StorageUtl_ReadWord(const BYTE
* buffer
, ULONG offset
, WORD
* value
);
435 void StorageUtl_WriteWord(BYTE
* buffer
, ULONG offset
, WORD value
);
436 void StorageUtl_ReadDWord(const BYTE
* buffer
, ULONG offset
, DWORD
* value
);
437 void StorageUtl_WriteDWord(BYTE
* buffer
, ULONG offset
, DWORD value
);
438 void StorageUtl_ReadULargeInteger(const BYTE
* buffer
, ULONG offset
,
439 ULARGE_INTEGER
* value
);
440 void StorageUtl_WriteULargeInteger(BYTE
* buffer
, ULONG offset
,
441 const ULARGE_INTEGER
*value
);
442 void StorageUtl_ReadGUID(const BYTE
* buffer
, ULONG offset
, GUID
* value
);
443 void StorageUtl_WriteGUID(BYTE
* buffer
, ULONG offset
, const GUID
* value
);
444 void StorageUtl_CopyDirEntryToSTATSTG(StorageBaseImpl
*storage
,STATSTG
* destination
,
445 const DirEntry
* source
, int statFlags
);
447 /****************************************************************************
448 * BlockChainStream definitions.
450 * The BlockChainStream class is a utility class that is used to create an
451 * abstraction of the big block chains in the storage file.
453 struct BlockChainStream
455 StorageImpl
* parentStorage
;
456 ULONG
* headOfStreamPlaceHolder
;
457 DirRef ownerDirEntry
;
458 ULONG lastBlockNoInSequence
;
459 ULONG lastBlockNoInSequenceIndex
;
465 * Methods for the BlockChainStream class.
467 BlockChainStream
* BlockChainStream_Construct(
468 StorageImpl
* parentStorage
,
469 ULONG
* headOfStreamPlaceHolder
,
472 void BlockChainStream_Destroy(
473 BlockChainStream
* This
);
475 HRESULT
BlockChainStream_ReadAt(
476 BlockChainStream
* This
,
477 ULARGE_INTEGER offset
,
482 HRESULT
BlockChainStream_WriteAt(
483 BlockChainStream
* This
,
484 ULARGE_INTEGER offset
,
487 ULONG
* bytesWritten
);
489 BOOL
BlockChainStream_SetSize(
490 BlockChainStream
* This
,
491 ULARGE_INTEGER newSize
);
493 /****************************************************************************
494 * SmallBlockChainStream definitions.
496 * The SmallBlockChainStream class is a utility class that is used to create an
497 * abstraction of the small block chains in the storage file.
499 struct SmallBlockChainStream
501 StorageImpl
* parentStorage
;
502 DirRef ownerDirEntry
;
503 ULONG
* headOfStreamPlaceHolder
;
507 * Methods of the SmallBlockChainStream class.
509 SmallBlockChainStream
* SmallBlockChainStream_Construct(
510 StorageImpl
* parentStorage
,
511 ULONG
* headOfStreamPlaceHolder
,
514 void SmallBlockChainStream_Destroy(
515 SmallBlockChainStream
* This
);
517 HRESULT
SmallBlockChainStream_ReadAt(
518 SmallBlockChainStream
* This
,
519 ULARGE_INTEGER offset
,
524 HRESULT
SmallBlockChainStream_WriteAt(
525 SmallBlockChainStream
* This
,
526 ULARGE_INTEGER offset
,
529 ULONG
* bytesWritten
);
531 BOOL
SmallBlockChainStream_SetSize(
532 SmallBlockChainStream
* This
,
533 ULARGE_INTEGER newSize
);
536 #endif /* __STORAGE32_H__ */