1 /*
2 * Compound Storage (32 bit version)
3 *
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>)
7 *
8 * This include file contains definitions of types and function
9 * prototypes that are used in the many files implementing the
10 * storage functionality
11 *
12 * Copyright 1998,1999 Francis Beaudet
13 * Copyright 1998,1999 Thuy Nguyen
14 *
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.
19 *
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.
24 *
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
28 */
29 #ifndef __STORAGE32_H__
30 #define __STORAGE32_H__
31
32 #include <stdarg.h>
33
34 #include "windef.h"
35 #include "winbase.h"
36 #include "winnt.h"
37 #include "objbase.h"
38 #include "winreg.h"
39 #include "winternl.h"
40 #include "wine/list.h"
41
42 /*
43 * Definitions for the file format offsets.
44 */
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;
76
77 #define PROPERTY_NAME_MAX_LEN 0x20
78 #define PROPERTY_NAME_BUFFER_LEN 0x40
79
80 #define PROPSET_BLOCK_SIZE 0x00000080
81
82 /*
83 * Property type of relation
84 */
85 #define PROPERTY_RELATION_PREVIOUS 0
86 #define PROPERTY_RELATION_NEXT 1
87 #define PROPERTY_RELATION_DIR 2
88
89 /*
90 * Property type constants
91 */
92 #define PROPTYPE_STORAGE 0x01
93 #define PROPTYPE_STREAM 0x02
94 #define PROPTYPE_ROOT 0x05
95
96 /*
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
99 * becomes the case.
100 */
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
105
106 #define STGM_ACCESS_MODE(stgm) ((stgm)&0x0000f)
107 #define STGM_SHARE_MODE(stgm) ((stgm)&0x000f0)
108 #define STGM_CREATE_MODE(stgm) ((stgm)&0x0f000)
109
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)
113
114 /*
115 * Forward declarations of all the structures used by the storage
116 * module.
117 */
118 typedef struct StorageBaseImpl StorageBaseImpl;
119 typedef struct StorageImpl StorageImpl;
120 typedef struct BlockChainStream BlockChainStream;
121 typedef struct SmallBlockChainStream SmallBlockChainStream;
122 typedef struct IEnumSTATSTGImpl IEnumSTATSTGImpl;
123 typedef struct StgProperty StgProperty;
124 typedef struct StgStreamImpl StgStreamImpl;
125
126 /*
127 * This utility structure is used to read/write the information in a storage
128 * property.
129 */
130 struct StgProperty
131 {
132 WCHAR name[PROPERTY_NAME_MAX_LEN];
133 WORD sizeOfNameString;
134 BYTE propertyType;
135 ULONG previousProperty;
136 ULONG nextProperty;
137 ULONG dirProperty;
138 GUID propertyUniqueID;
139 ULONG timeStampS1;
140 ULONG timeStampD1;
141 ULONG timeStampS2;
142 ULONG timeStampD2;
143 ULONG startingBlock;
144 ULARGE_INTEGER size;
145 };
146
147 /*************************************************************************
148 * Big Block File support
149 *
150 * The big block file is an abstraction of a flat file separated in
151 * same sized blocks. The implementation for the methods described in
152 * this section appear in stg_bigblockfile.c
153 */
154
155 /*
156 * Declaration of the data structures
157 */
158 typedef struct BigBlockFile BigBlockFile,*LPBIGBLOCKFILE;
159 typedef struct MappedPage MappedPage,*LPMAPPEDPAGE;
160
161 struct BigBlockFile
162 {
163 BOOL fileBased;
164 ULARGE_INTEGER filesize;
165 ULONG blocksize;
166 HANDLE hfile;
167 HANDLE hfilemap;
168 DWORD flProtect;
169 MappedPage *maplist;
170 MappedPage *victimhead, *victimtail;
171 ULONG num_victim_pages;
172 ILockBytes *pLkbyt;
173 HGLOBAL hbytearray;
174 LPVOID pbytearray;
175 };
176
177 /*
178 * Declaration of the functions used to manipulate the BigBlockFile
179 * data structure.
180 */
181 BigBlockFile* BIGBLOCKFILE_Construct(HANDLE hFile,
182 ILockBytes* pLkByt,
183 DWORD openFlags,
184 ULONG blocksize,
185 BOOL fileBased);
186 void BIGBLOCKFILE_Destructor(LPBIGBLOCKFILE This);
187 void BIGBLOCKFILE_EnsureExists(LPBIGBLOCKFILE This, ULONG index);
188 void BIGBLOCKFILE_SetSize(LPBIGBLOCKFILE This, ULARGE_INTEGER newSize);
189 HRESULT BIGBLOCKFILE_ReadAt(LPBIGBLOCKFILE This, ULARGE_INTEGER offset,
190 void* buffer, ULONG size, ULONG* bytesRead);
191 HRESULT BIGBLOCKFILE_WriteAt(LPBIGBLOCKFILE This, ULARGE_INTEGER offset,
192 const void* buffer, ULONG size, ULONG* bytesRead);
193
194 /*************************************************************************
195 * Ole Convert support
196 */
197
198 void OLECONVERT_CreateOleStream(LPSTORAGE pStorage);
199 HRESULT OLECONVERT_CreateCompObjStream(LPSTORAGE pStorage, LPCSTR strOleTypeName);
200
201 /****************************************************************************
202 * Storage32BaseImpl definitions.
203 *
204 * This structure defines the base information contained in all implementations
205 * of IStorage32 contained in this file storage implementation.
206 *
207 * In OOP terms, this is the base class for all the IStorage32 implementations
208 * contained in this file.
209 */
210 struct StorageBaseImpl
211 {
212 const IStorageVtbl *lpVtbl; /* Needs to be the first item in the struct
213 * since we want to cast this in a Storage32 pointer */
214
215 const IPropertySetStorageVtbl *pssVtbl; /* interface for adding a properties stream */
216
217 /*
218 * Stream tracking list
219 */
220
221 struct list strmHead;
222
223 /*
224 * Reference count of this object
225 */
226 LONG ref;
227
228 /*
229 * Ancestor storage (top level)
230 */
231 StorageImpl* ancestorStorage;
232
233 /*
234 * Index of the property for the root of
235 * this storage
236 */
237 ULONG rootPropertySetIndex;
238
239 /*
240 * virtual Destructor method.
241 */
242 void (*v_destructor)(StorageBaseImpl*);
243
244 /*
245 * flags that this storage was opened or created with
246 */
247 DWORD openFlags;
248
249 /*
250 * State bits appear to only be preserved while running. No in the stream
251 */
252 DWORD stateBits;
253 };
254
255 /****************************************************************************
256 * StorageBaseImpl stream list handlers
257 */
258
259 void StorageBaseImpl_AddStream(StorageBaseImpl * stg, StgStreamImpl * strm);
260 void StorageBaseImpl_RemoveStream(StorageBaseImpl * stg, StgStreamImpl * strm);
261
262 /****************************************************************************
263 * Storage32Impl definitions.
264 *
265 * This implementation of the IStorage32 interface represents a root
266 * storage. Basically, a document file.
267 */
268 struct StorageImpl
269 {
270 struct StorageBaseImpl base;
271
272 /*
273 * The following data members are specific to the Storage32Impl
274 * class
275 */
276 HANDLE hFile; /* Physical support for the Docfile */
277 LPOLESTR pwcsName; /* Full path of the document file */
278
279 /* FIXME: should this be in Storage32BaseImpl ? */
280 WCHAR filename[PROPERTY_NAME_BUFFER_LEN];
281
282 /*
283 * File header
284 */
285 WORD bigBlockSizeBits;
286 WORD smallBlockSizeBits;
287 ULONG bigBlockSize;
288 ULONG smallBlockSize;
289 ULONG bigBlockDepotCount;
290 ULONG rootStartBlock;
291 ULONG smallBlockDepotStart;
292 ULONG extBigBlockDepotStart;
293 ULONG extBigBlockDepotCount;
294 ULONG bigBlockDepotStart[COUNT_BBDEPOTINHEADER];
295
296 ULONG blockDepotCached[NUM_BLOCKS_PER_DEPOT_BLOCK];
297 ULONG indexBlockDepotCached;
298 ULONG prevFreeBlock;
299
300 /*
301 * Abstraction of the big block chains for the chains of the header.
302 */
303 BlockChainStream* rootBlockChain;
304 BlockChainStream* smallBlockDepotChain;
305 BlockChainStream* smallBlockRootChain;
306
307 /*
308 * Pointer to the big block file abstraction
309 */
310 BigBlockFile* bigBlockFile;
311 };
312
313 BOOL StorageImpl_ReadProperty(
314 StorageImpl* This,
315 ULONG index,
316 StgProperty* buffer);
317
318 BOOL StorageImpl_WriteProperty(
319 StorageImpl* This,
320 ULONG index,
321 const StgProperty* buffer);
322
323 BlockChainStream* Storage32Impl_SmallBlocksToBigBlocks(
324 StorageImpl* This,
325 SmallBlockChainStream** ppsbChain);
326
327 /****************************************************************************
328 * StgStreamImpl definitions.
329 *
330 * This class implements the IStream32 interface and represents a stream
331 * located inside a storage object.
332 */
333 struct StgStreamImpl
334 {
335 const IStreamVtbl *lpVtbl; /* Needs to be the first item in the struct
336 * since we want to cast this to an IStream pointer */
337
338 /*
339 * We are an entry in the storage object's stream handler list
340 */
341
342 struct list StrmListEntry;
343
344 /*
345 * Reference count
346 */
347 LONG ref;
348
349 /*
350 * Storage that is the parent(owner) of the stream
351 */
352 StorageBaseImpl* parentStorage;
353
354 /*
355 * Access mode of this stream.
356 */
357 DWORD grfMode;
358
359 /*
360 * Index of the property that owns (points to) this stream.
361 */
362 ULONG ownerProperty;
363
364 /*
365 * Helper variable that contains the size of the stream
366 */
367 ULARGE_INTEGER streamSize;
368
369 /*
370 * This is the current position of the cursor in the stream
371 */
372 ULARGE_INTEGER currentPosition;
373
374 /*
375 * The information in the stream is represented by a chain of small blocks
376 * or a chain of large blocks. Depending on the case, one of the two
377 * following variables points to that information.
378 */
379 BlockChainStream* bigBlockChain;
380 SmallBlockChainStream* smallBlockChain;
381 };
382
383 /*
384 * Method definition for the StgStreamImpl class.
385 */
386 StgStreamImpl* StgStreamImpl_Construct(
387 StorageBaseImpl* parentStorage,
388 DWORD grfMode,
389 ULONG ownerProperty);
390
391
392 /******************************************************************************
393 * Endian conversion macros
394 */
395 #ifdef WORDS_BIGENDIAN
396
397 #define htole32(x) RtlUlongByteSwap(x)
398 #define htole16(x) RtlUshortByteSwap(x)
399 #define le32toh(x) RtlUlongByteSwap(x)
400 #define le16toh(x) RtlUshortByteSwap(x)
401
402 #else
403
404 #define htole32(x) (x)
405 #define htole16(x) (x)
406 #define le32toh(x) (x)
407 #define le16toh(x) (x)
408
409 #endif
410
411 /******************************************************************************
412 * The StorageUtl_ functions are miscellaneous utility functions. Most of which
413 * are abstractions used to read values from file buffers without having to
414 * worry about bit order
415 */
416 void StorageUtl_ReadWord(const BYTE* buffer, ULONG offset, WORD* value);
417 void StorageUtl_WriteWord(BYTE* buffer, ULONG offset, WORD value);
418 void StorageUtl_ReadDWord(const BYTE* buffer, ULONG offset, DWORD* value);
419 void StorageUtl_WriteDWord(BYTE* buffer, ULONG offset, DWORD value);
420 void StorageUtl_ReadULargeInteger(const BYTE* buffer, ULONG offset,
421 ULARGE_INTEGER* value);
422 void StorageUtl_WriteULargeInteger(BYTE* buffer, ULONG offset,
423 const ULARGE_INTEGER *value);
424 void StorageUtl_ReadGUID(const BYTE* buffer, ULONG offset, GUID* value);
425 void StorageUtl_WriteGUID(BYTE* buffer, ULONG offset, const GUID* value);
426 void StorageUtl_CopyPropertyToSTATSTG(STATSTG* destination, const StgProperty* source,
427 int statFlags);
428
429 /****************************************************************************
430 * BlockChainStream definitions.
431 *
432 * The BlockChainStream class is a utility class that is used to create an
433 * abstraction of the big block chains in the storage file.
434 */
435 struct BlockChainStream
436 {
437 StorageImpl* parentStorage;
438 ULONG* headOfStreamPlaceHolder;
439 ULONG ownerPropertyIndex;
440 ULONG lastBlockNoInSequence;
441 ULONG lastBlockNoInSequenceIndex;
442 ULONG tailIndex;
443 ULONG numBlocks;
444 };
445
446 /*
447 * Methods for the BlockChainStream class.
448 */
449 BlockChainStream* BlockChainStream_Construct(
450 StorageImpl* parentStorage,
451 ULONG* headOfStreamPlaceHolder,
452 ULONG propertyIndex);
453
454 void BlockChainStream_Destroy(
455 BlockChainStream* This);
456
457 HRESULT BlockChainStream_ReadAt(
458 BlockChainStream* This,
459 ULARGE_INTEGER offset,
460 ULONG size,
461 void* buffer,
462 ULONG* bytesRead);
463
464 HRESULT BlockChainStream_WriteAt(
465 BlockChainStream* This,
466 ULARGE_INTEGER offset,
467 ULONG size,
468 const void* buffer,
469 ULONG* bytesWritten);
470
471 BOOL BlockChainStream_SetSize(
472 BlockChainStream* This,
473 ULARGE_INTEGER newSize);
474
475 /****************************************************************************
476 * SmallBlockChainStream definitions.
477 *
478 * The SmallBlockChainStream class is a utility class that is used to create an
479 * abstraction of the small block chains in the storage file.
480 */
481 struct SmallBlockChainStream
482 {
483 StorageImpl* parentStorage;
484 ULONG ownerPropertyIndex;
485 };
486
487 /*
488 * Methods of the SmallBlockChainStream class.
489 */
490 SmallBlockChainStream* SmallBlockChainStream_Construct(
491 StorageImpl* parentStorage,
492 ULONG propertyIndex);
493
494 void SmallBlockChainStream_Destroy(
495 SmallBlockChainStream* This);
496
497 HRESULT SmallBlockChainStream_ReadAt(
498 SmallBlockChainStream* This,
499 ULARGE_INTEGER offset,
500 ULONG size,
501 void* buffer,
502 ULONG* bytesRead);
503
504 HRESULT SmallBlockChainStream_WriteAt(
505 SmallBlockChainStream* This,
506 ULARGE_INTEGER offset,
507 ULONG size,
508 const void* buffer,
509 ULONG* bytesWritten);
510
511 BOOL SmallBlockChainStream_SetSize(
512 SmallBlockChainStream* This,
513 ULARGE_INTEGER newSize);
514
515
516 #endif /* __STORAGE32_H__ */
517
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.