source: trunk/src/ole32/storage32.h@ 9101

Last change on this file since 9101 was 8441, checked in by sandervl, 23 years ago

Wine resync
File size: 27.7 KB
Line 
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 */
29#ifndef __STORAGE32_H__
30#define __STORAGE32_H__
31
32#include "wtypes.h"
33#include "winnt.h"
34#include "wine/obj_base.h"
35#include "wine/obj_storage.h"
36
37/*
38 * Definitions for the file format offsets.
39 */
40static const ULONG OFFSET_BIGBLOCKSIZEBITS = 0x0000001e;
41static const ULONG OFFSET_SMALLBLOCKSIZEBITS = 0x00000020;
42static const ULONG OFFSET_BBDEPOTCOUNT = 0x0000002C;
43static const ULONG OFFSET_ROOTSTARTBLOCK = 0x00000030;
44static const ULONG OFFSET_SBDEPOTSTART = 0x0000003C;
45static const ULONG OFFSET_EXTBBDEPOTSTART = 0x00000044;
46static const ULONG OFFSET_EXTBBDEPOTCOUNT = 0x00000048;
47static const ULONG OFFSET_BBDEPOTSTART = 0x0000004C;
48static const ULONG OFFSET_PS_NAME = 0x00000000;
49static const ULONG OFFSET_PS_NAMELENGTH = 0x00000040;
50static const ULONG OFFSET_PS_PROPERTYTYPE = 0x00000042;
51static const ULONG OFFSET_PS_PREVIOUSPROP = 0x00000044;
52static const ULONG OFFSET_PS_NEXTPROP = 0x00000048;
53static const ULONG OFFSET_PS_DIRPROP = 0x0000004C;
54static const ULONG OFFSET_PS_GUID = 0x00000050;
55static const ULONG OFFSET_PS_TSS1 = 0x00000064;
56static const ULONG OFFSET_PS_TSD1 = 0x00000068;
57static const ULONG OFFSET_PS_TSS2 = 0x0000006C;
58static const ULONG OFFSET_PS_TSD2 = 0x00000070;
59static const ULONG OFFSET_PS_STARTBLOCK = 0x00000074;
60static const ULONG OFFSET_PS_SIZE = 0x00000078;
61static const WORD DEF_BIG_BLOCK_SIZE_BITS = 0x0009;
62static const WORD DEF_SMALL_BLOCK_SIZE_BITS = 0x0006;
63static const WORD DEF_BIG_BLOCK_SIZE = 0x0200;
64static const WORD DEF_SMALL_BLOCK_SIZE = 0x0040;
65static const ULONG BLOCK_EXTBBDEPOT = 0xFFFFFFFC;
66static const ULONG BLOCK_SPECIAL = 0xFFFFFFFD;
67static const ULONG BLOCK_END_OF_CHAIN = 0xFFFFFFFE;
68static const ULONG BLOCK_UNUSED = 0xFFFFFFFF;
69static const ULONG PROPERTY_NULL = 0xFFFFFFFF;
70
71#define PROPERTY_NAME_MAX_LEN 0x20
72#define PROPERTY_NAME_BUFFER_LEN 0x40
73
74#define PROPSET_BLOCK_SIZE 0x00000080
75
76/*
77 * Property type of relation
78 */
79#define PROPERTY_RELATION_PREVIOUS 0
80#define PROPERTY_RELATION_NEXT 1
81#define PROPERTY_RELATION_DIR 2
82
83/*
84 * Property type constants
85 */
86#define PROPTYPE_STORAGE 0x01
87#define PROPTYPE_STREAM 0x02
88#define PROPTYPE_ROOT 0x05
89
90/*
91 * These defines assume a hardcoded blocksize. The code will assert
92 * if the blocksize is different. Some changes will have to be done if it
93 * becomes the case.
94 */
95#define BIG_BLOCK_SIZE 0x200
96#define COUNT_BBDEPOTINHEADER 109
97#define LIMIT_TO_USE_SMALL_BLOCK 0x1000
98#define NUM_BLOCKS_PER_DEPOT_BLOCK 128
99
100/*
101 * These are signatures to detect the type of Document file.
102 */
103static const BYTE STORAGE_magic[8] ={0xd0,0xcf,0x11,0xe0,0xa1,0xb1,0x1a,0xe1};
104static const BYTE STORAGE_oldmagic[8] ={0xd0,0xcf,0x11,0xe0,0x0e,0x11,0xfc,0x0d};
105
106/*
107 * Forward declarations of all the structures used by the storage
108 * module.
109 */
110typedef struct StorageBaseImpl StorageBaseImpl;
111typedef struct StorageImpl StorageImpl;
112typedef struct StorageInternalImpl StorageInternalImpl;
113typedef struct BlockChainStream BlockChainStream;
114typedef struct SmallBlockChainStream SmallBlockChainStream;
115typedef struct IEnumSTATSTGImpl IEnumSTATSTGImpl;
116typedef struct StgProperty StgProperty;
117typedef struct StgStreamImpl StgStreamImpl;
118
119/*
120 * This utility structure is used to read/write the information in a storage
121 * property.
122 */
123struct StgProperty
124{
125 WCHAR name[PROPERTY_NAME_MAX_LEN];
126 WORD sizeOfNameString;
127 BYTE propertyType;
128 ULONG previousProperty;
129 ULONG nextProperty;
130 ULONG dirProperty;
131 GUID propertyUniqueID;
132 ULONG timeStampS1;
133 ULONG timeStampD1;
134 ULONG timeStampS2;
135 ULONG timeStampD2;
136 ULONG startingBlock;
137 ULARGE_INTEGER size;
138};
139
140/*************************************************************************
141 * Big Block File support
142 *
143 * The big block file is an abstraction of a flat file separated in
144 * same sized blocks. The implementation for the methods described in
145 * this section appear in stg_bigblockfile.c
146 */
147
148/*
149 * Declaration of the data structures
150 */
151typedef struct BigBlockFile BigBlockFile,*LPBIGBLOCKFILE;
152typedef struct MappedPage MappedPage,*LPMAPPEDPAGE;
153
154struct BigBlockFile
155{
156 BOOL fileBased;
157 ULARGE_INTEGER filesize;
158 ULONG blocksize;
159 HANDLE hfile;
160 HANDLE hfilemap;
161 DWORD flProtect;
162 MappedPage *maplist;
163 MappedPage *victimhead, *victimtail;
164 ULONG num_victim_pages;
165 ILockBytes *pLkbyt;
166 HGLOBAL hbytearray;
167 LPVOID pbytearray;
168};
169
170/*
171 * Declaration of the functions used to manipulate the BigBlockFile
172 * data structure.
173 */
174BigBlockFile* BIGBLOCKFILE_Construct(HANDLE hFile,
175 ILockBytes* pLkByt,
176 DWORD openFlags,
177 ULONG blocksize,
178 BOOL fileBased);
179void BIGBLOCKFILE_Destructor(LPBIGBLOCKFILE This);
180void* BIGBLOCKFILE_GetBigBlock(LPBIGBLOCKFILE This, ULONG index);
181void* BIGBLOCKFILE_GetROBigBlock(LPBIGBLOCKFILE This, ULONG index);
182void BIGBLOCKFILE_ReleaseBigBlock(LPBIGBLOCKFILE This, void *pBlock);
183void BIGBLOCKFILE_SetSize(LPBIGBLOCKFILE This, ULARGE_INTEGER newSize);
184ULARGE_INTEGER BIGBLOCKFILE_GetSize(LPBIGBLOCKFILE This);
185
186/*************************************************************************
187 * Ole Convert support
188 */
189
190void OLECONVERT_CreateOleStream(LPSTORAGE pStorage);
191HRESULT OLECONVERT_CreateCompObjStream(LPSTORAGE pStorage, LPCSTR strOleTypeName);
192
193/****************************************************************************
194 * Storage32BaseImpl definitions.
195 *
196 * This structure defines the base information contained in all implementations
197 * of IStorage32 contained in this file storage implementation.
198 *
199 * In OOP terms, this is the base class for all the IStorage32 implementations
200 * contained in this file.
201 */
202struct StorageBaseImpl
203{
204 ICOM_VFIELD(IStorage); /* Needs to be the first item in the struct
205 * since we want to cast this in a Storage32 pointer */
206
207 /*
208 * Reference count of this object
209 */
210 ULONG ref;
211
212 /*
213 * Ancestor storage (top level)
214 */
215 StorageImpl* ancestorStorage;
216
217 /*
218 * Index of the property for the root of
219 * this storage
220 */
221 ULONG rootPropertySetIndex;
222
223 /*
224 * virtual Destructor method.
225 */
226 void (*v_destructor)(StorageBaseImpl*);
227};
228
229
230/*
231 * Prototypes for the methods of the Storage32BaseImpl class.
232 */
233HRESULT WINAPI StorageBaseImpl_QueryInterface(
234 IStorage* iface,
235 REFIID riid,
236 void** ppvObject);
237
238ULONG WINAPI StorageBaseImpl_AddRef(
239 IStorage* iface);
240
241ULONG WINAPI StorageBaseImpl_Release(
242 IStorage* iface);
243
244HRESULT WINAPI StorageBaseImpl_OpenStream(
245 IStorage* iface,
246 const OLECHAR* pwcsName, /* [string][in] */
247 void* reserved1, /* [unique][in] */
248 DWORD grfMode, /* [in] */
249 DWORD reserved2, /* [in] */
250 IStream** ppstm); /* [out] */
251
252HRESULT WINAPI StorageBaseImpl_OpenStorage(
253 IStorage* iface,
254 const OLECHAR* pwcsName, /* [string][unique][in] */
255 IStorage* pstgPriority, /* [unique][in] */
256 DWORD grfMode, /* [in] */
257 SNB snbExclude, /* [unique][in] */
258 DWORD reserved, /* [in] */
259 IStorage** ppstg); /* [out] */
260
261HRESULT WINAPI StorageBaseImpl_EnumElements(
262 IStorage* iface,
263 DWORD reserved1, /* [in] */
264 void* reserved2, /* [size_is][unique][in] */
265 DWORD reserved3, /* [in] */
266 IEnumSTATSTG** ppenum); /* [out] */
267
268HRESULT WINAPI StorageBaseImpl_Stat(
269 IStorage* iface,
270 STATSTG* pstatstg, /* [out] */
271 DWORD grfStatFlag); /* [in] */
272
273HRESULT WINAPI StorageBaseImpl_RenameElement(
274 IStorage* iface,
275 const OLECHAR* pwcsOldName, /* [string][in] */
276 const OLECHAR* pwcsNewName); /* [string][in] */
277
278HRESULT WINAPI StorageBaseImpl_CreateStream(
279 IStorage* iface,
280 const OLECHAR* pwcsName, /* [string][in] */
281 DWORD grfMode, /* [in] */
282 DWORD reserved1, /* [in] */
283 DWORD reserved2, /* [in] */
284 IStream** ppstm); /* [out] */
285
286HRESULT WINAPI StorageBaseImpl_SetClass(
287 IStorage* iface,
288 REFCLSID clsid); /* [in] */
289
290/****************************************************************************
291 * Storage32Impl definitions.
292 *
293 * This implementation of the IStorage32 interface represents a root
294 * storage. Basically, a document file.
295 */
296struct StorageImpl
297{
298 ICOM_VFIELD(IStorage); /* Needs to be the first item in the struct
299 * since we want to cast this in a Storage32 pointer */
300
301 /*
302 * Declare the member of the Storage32BaseImpl class to allow
303 * casting as a Storage32BaseImpl
304 */
305 ULONG ref;
306 struct StorageImpl* ancestorStorage;
307 ULONG rootPropertySetIndex;
308 void (*v_destructor)(struct StorageImpl*);
309
310 /*
311 * The following data members are specific to the Storage32Impl
312 * class
313 */
314 HANDLE hFile; /* Physical support for the Docfile */
315 LPOLESTR pwcsName; /* Full path of the document file */
316
317 /* FIXME: should this be in Storage32BaseImpl ? */
318 WCHAR filename[PROPERTY_NAME_BUFFER_LEN];
319
320 /*
321 * File header
322 */
323 WORD bigBlockSizeBits;
324 WORD smallBlockSizeBits;
325 ULONG bigBlockSize;
326 ULONG smallBlockSize;
327 ULONG bigBlockDepotCount;
328 ULONG rootStartBlock;
329 ULONG smallBlockDepotStart;
330 ULONG extBigBlockDepotStart;
331 ULONG extBigBlockDepotCount;
332 ULONG bigBlockDepotStart[COUNT_BBDEPOTINHEADER];
333
334 ULONG blockDepotCached[NUM_BLOCKS_PER_DEPOT_BLOCK];
335 ULONG indexBlockDepotCached;
336 ULONG prevFreeBlock;
337
338 /*
339 * Abstraction of the big block chains for the chains of the header.
340 */
341 BlockChainStream* rootBlockChain;
342 BlockChainStream* smallBlockDepotChain;
343 BlockChainStream* smallBlockRootChain;
344
345 /*
346 * Pointer to the big block file abstraction
347 */
348 BigBlockFile* bigBlockFile;
349};
350
351/*
352 * Method declaration for the Storage32Impl class
353 */
354
355HRESULT WINAPI StorageImpl_CreateStorage(
356 IStorage* iface,
357 const OLECHAR* pwcsName, /* [string][in] */
358 DWORD grfMode, /* [in] */
359 DWORD dwStgFmt, /* [in] */
360 DWORD reserved2, /* [in] */
361 IStorage** ppstg); /* [out] */
362
363HRESULT WINAPI StorageImpl_CopyTo(
364 IStorage* iface,
365 DWORD ciidExclude, /* [in] */
366 const IID* rgiidExclude, /* [size_is][unique][in] */
367 SNB snbExclude, /* [unique][in] */
368 IStorage* pstgDest); /* [unique][in] */
369
370HRESULT WINAPI StorageImpl_MoveElementTo(
371 IStorage* iface,
372 const OLECHAR* pwcsName, /* [string][in] */
373 IStorage* pstgDest, /* [unique][in] */
374 const OLECHAR* pwcsNewName, /* [string][in] */
375 DWORD grfFlags); /* [in] */
376
377HRESULT WINAPI StorageImpl_Commit(
378 IStorage* iface,
379 DWORD grfCommitFlags); /* [in] */
380
381HRESULT WINAPI StorageImpl_Revert(
382 IStorage* iface);
383
384HRESULT WINAPI StorageImpl_DestroyElement(
385 IStorage* iface,
386 const OLECHAR* pwcsName); /* [string][in] */
387
388HRESULT WINAPI StorageImpl_SetElementTimes(
389 IStorage* iface,
390 const OLECHAR* pwcsName, /* [string][in] */
391 const FILETIME* pctime, /* [in] */
392 const FILETIME* patime, /* [in] */
393 const FILETIME* pmtime); /* [in] */
394
395HRESULT WINAPI StorageImpl_SetStateBits(
396 IStorage* iface,
397 DWORD grfStateBits, /* [in] */
398 DWORD grfMask); /* [in] */
399
400HRESULT WINAPI StorageImpl_Stat(IStorage* iface,
401 STATSTG* pstatstg, /* [out] */
402 DWORD grfStatFlag); /* [in] */
403
404void StorageImpl_Destroy(
405 StorageImpl* This);
406
407HRESULT StorageImpl_Construct(
408 StorageImpl* This,
409 HANDLE hFile,
410 LPCOLESTR pwcsName,
411 ILockBytes* pLkbyt,
412 DWORD openFlags,
413 BOOL fileBased,
414 BOOL fileCreate);
415
416BOOL StorageImpl_ReadBigBlock(
417 StorageImpl* This,
418 ULONG blockIndex,
419 void* buffer);
420
421BOOL StorageImpl_WriteBigBlock(
422 StorageImpl* This,
423 ULONG blockIndex,
424 void* buffer);
425
426void* StorageImpl_GetROBigBlock(
427 StorageImpl* This,
428 ULONG blockIndex);
429
430void* StorageImpl_GetBigBlock(
431 StorageImpl* This,
432 ULONG blockIndex);
433
434void StorageImpl_ReleaseBigBlock(
435 StorageImpl* This,
436 void* pBigBlock);
437
438ULONG StorageImpl_GetNextFreeBigBlock(
439 StorageImpl* This);
440
441void StorageImpl_FreeBigBlock(
442 StorageImpl* This,
443 ULONG blockIndex);
444
445ULONG StorageImpl_GetNextBlockInChain(
446 StorageImpl* This,
447 ULONG blockIndex);
448
449void StorageImpl_SetNextBlockInChain(
450 StorageImpl* This,
451 ULONG blockIndex,
452 ULONG nextBlock);
453
454HRESULT StorageImpl_LoadFileHeader(
455 StorageImpl* This);
456
457void StorageImpl_SaveFileHeader(
458 StorageImpl* This);
459
460BOOL StorageImpl_ReadProperty(
461 StorageImpl* This,
462 ULONG index,
463 StgProperty* buffer);
464
465BOOL StorageImpl_WriteProperty(
466 StorageImpl* This,
467 ULONG index,
468 StgProperty* buffer);
469
470BlockChainStream* Storage32Impl_SmallBlocksToBigBlocks(
471 StorageImpl* This,
472 SmallBlockChainStream** ppsbChain);
473
474ULONG Storage32Impl_GetNextExtendedBlock(StorageImpl* This,
475 ULONG blockIndex);
476
477void Storage32Impl_AddBlockDepot(StorageImpl* This,
478 ULONG blockIndex);
479
480ULONG Storage32Impl_AddExtBlockDepot(StorageImpl* This);
481
482ULONG Storage32Impl_GetExtDepotBlock(StorageImpl* This,
483 ULONG depotIndex);
484
485void Storage32Impl_SetExtDepotBlock(StorageImpl* This,
486 ULONG depotIndex,
487 ULONG blockIndex);
488/****************************************************************************
489 * Storage32InternalImpl definitions.
490 *
491 * Definition of the implementation structure for the IStorage32 interface.
492 * This one implements the IStorage32 interface for storage that are
493 * inside another storage.
494 */
495struct StorageInternalImpl
496{
497 ICOM_VFIELD(IStorage); /* Needs to be the first item in the struct
498 * since we want to cast this in a Storage32 pointer */
499
500 /*
501 * Declare the member of the Storage32BaseImpl class to allow
502 * casting as a Storage32BaseImpl
503 */
504 ULONG ref;
505 struct StorageImpl* ancestorStorage;
506 ULONG rootPropertySetIndex;
507 void (*v_destructor)(struct StorageInternalImpl*);
508
509 /*
510 * There is no specific data for this class.
511 */
512};
513
514/*
515 * Method definitions for the Storage32InternalImpl class.
516 */
517StorageInternalImpl* StorageInternalImpl_Construct(
518 StorageImpl* ancestorStorage,
519 ULONG rootTropertyIndex);
520
521void StorageInternalImpl_Destroy(
522 StorageInternalImpl* This);
523
524HRESULT WINAPI StorageInternalImpl_Commit(
525 IStorage* iface,
526 DWORD grfCommitFlags); /* [in] */
527
528HRESULT WINAPI StorageInternalImpl_Revert(
529 IStorage* iface);
530
531
532/****************************************************************************
533 * IEnumSTATSTGImpl definitions.
534 *
535 * Definition of the implementation structure for the IEnumSTATSTGImpl interface.
536 * This class allows iterating through the content of a storage and to find
537 * specific items inside it.
538 */
539struct IEnumSTATSTGImpl
540{
541 ICOM_VFIELD(IEnumSTATSTG); /* Needs to be the first item in the struct
542 * since we want to cast this in a IEnumSTATSTG pointer */
543
544 ULONG ref; /* Reference count */
545 StorageImpl* parentStorage; /* Reference to the parent storage */
546 ULONG firstPropertyNode; /* Index of the root of the storage to enumerate */
547
548 /*
549 * The current implementation of the IEnumSTATSTGImpl class uses a stack
550 * to walk the property sets to get the content of a storage. This stack
551 * is implemented by the following 3 data members
552 */
553 ULONG stackSize;
554 ULONG stackMaxSize;
555 ULONG* stackToVisit;
556
557#define ENUMSTATSGT_SIZE_INCREMENT 10
558};
559
560/*
561 * Method definitions for the IEnumSTATSTGImpl class.
562 */
563HRESULT WINAPI IEnumSTATSTGImpl_QueryInterface(
564 IEnumSTATSTG* iface,
565 REFIID riid,
566 void** ppvObject);
567
568ULONG WINAPI IEnumSTATSTGImpl_AddRef(
569 IEnumSTATSTG* iface);
570
571ULONG WINAPI IEnumSTATSTGImpl_Release(
572 IEnumSTATSTG* iface);
573
574HRESULT WINAPI IEnumSTATSTGImpl_Next(
575 IEnumSTATSTG* iface,
576 ULONG celt,
577 STATSTG* rgelt,
578 ULONG* pceltFetched);
579
580HRESULT WINAPI IEnumSTATSTGImpl_Skip(
581 IEnumSTATSTG* iface,
582 ULONG celt);
583
584HRESULT WINAPI IEnumSTATSTGImpl_Reset(
585 IEnumSTATSTG* iface);
586
587HRESULT WINAPI IEnumSTATSTGImpl_Clone(
588 IEnumSTATSTG* iface,
589 IEnumSTATSTG** ppenum);
590
591IEnumSTATSTGImpl* IEnumSTATSTGImpl_Construct(
592 StorageImpl* This,
593 ULONG firstPropertyNode);
594
595void IEnumSTATSTGImpl_Destroy(
596 IEnumSTATSTGImpl* This);
597
598void IEnumSTATSTGImpl_PushSearchNode(
599 IEnumSTATSTGImpl* This,
600 ULONG nodeToPush);
601
602ULONG IEnumSTATSTGImpl_PopSearchNode(
603 IEnumSTATSTGImpl* This,
604 BOOL remove);
605
606ULONG IEnumSTATSTGImpl_FindProperty(
607 IEnumSTATSTGImpl* This,
608 const OLECHAR* lpszPropName,
609 StgProperty* buffer);
610
611INT IEnumSTATSTGImpl_FindParentProperty(
612 IEnumSTATSTGImpl *This,
613 ULONG childProperty,
614 StgProperty *currentProperty,
615 ULONG *propertyId);
616
617
618/****************************************************************************
619 * StgStreamImpl definitions.
620 *
621 * This class imlements the IStream32 inteface and represents a stream
622 * located inside a storage object.
623 */
624struct StgStreamImpl
625{
626 ICOM_VFIELD(IStream); /* Needs to be the first item in the struct
627 * since we want to cast this in a IStream pointer */
628
629 /*
630 * Reference count
631 */
632 ULONG ref;
633
634 /*
635 * Storage that is the parent(owner) of the stream
636 */
637 StorageBaseImpl* parentStorage;
638
639 /*
640 * Access mode of this stream.
641 */
642 DWORD grfMode;
643
644 /*
645 * Index of the property that owns (points to) this stream.
646 */
647 ULONG ownerProperty;
648
649 /*
650 * Helper variable that contains the size of the stream
651 */
652 ULARGE_INTEGER streamSize;
653
654 /*
655 * This is the current position of the cursor in the stream
656 */
657 ULARGE_INTEGER currentPosition;
658
659 /*
660 * The information in the stream is represented by a chain of small blocks
661 * or a chain of large blocks. Depending on the case, one of the two
662 * following variabled points to that information.
663 */
664 BlockChainStream* bigBlockChain;
665 SmallBlockChainStream* smallBlockChain;
666};
667
668/*
669 * Method definition for the StgStreamImpl class.
670 */
671StgStreamImpl* StgStreamImpl_Construct(
672 StorageBaseImpl* parentStorage,
673 DWORD grfMode,
674 ULONG ownerProperty);
675
676void StgStreamImpl_Destroy(
677 StgStreamImpl* This);
678
679void StgStreamImpl_OpenBlockChain(
680 StgStreamImpl* This);
681
682HRESULT WINAPI StgStreamImpl_QueryInterface(
683 IStream* iface,
684 REFIID riid, /* [in] */
685 void** ppvObject); /* [iid_is][out] */
686
687ULONG WINAPI StgStreamImpl_AddRef(
688 IStream* iface);
689
690ULONG WINAPI StgStreamImpl_Release(
691 IStream* iface);
692
693HRESULT WINAPI StgStreamImpl_Read(
694 IStream* iface,
695 void* pv, /* [length_is][size_is][out] */
696 ULONG cb, /* [in] */
697 ULONG* pcbRead); /* [out] */
698
699HRESULT WINAPI StgStreamImpl_Write(
700 IStream* iface,
701 const void* pv, /* [size_is][in] */
702 ULONG cb, /* [in] */
703 ULONG* pcbWritten); /* [out] */
704
705HRESULT WINAPI StgStreamImpl_Seek(
706 IStream* iface,
707 LARGE_INTEGER dlibMove, /* [in] */
708 DWORD dwOrigin, /* [in] */
709 ULARGE_INTEGER* plibNewPosition); /* [out] */
710
711HRESULT WINAPI StgStreamImpl_SetSize(
712 IStream* iface,
713 ULARGE_INTEGER libNewSize); /* [in] */
714
715HRESULT WINAPI StgStreamImpl_CopyTo(
716 IStream* iface,
717 IStream* pstm, /* [unique][in] */
718 ULARGE_INTEGER cb, /* [in] */
719 ULARGE_INTEGER* pcbRead, /* [out] */
720 ULARGE_INTEGER* pcbWritten); /* [out] */
721
722HRESULT WINAPI StgStreamImpl_Commit(
723 IStream* iface,
724 DWORD grfCommitFlags); /* [in] */
725
726HRESULT WINAPI StgStreamImpl_Revert(
727 IStream* iface);
728
729HRESULT WINAPI StgStreamImpl_LockRegion(
730 IStream* iface,
731 ULARGE_INTEGER libOffset, /* [in] */
732 ULARGE_INTEGER cb, /* [in] */
733 DWORD dwLockType); /* [in] */
734
735HRESULT WINAPI StgStreamImpl_UnlockRegion(
736 IStream* iface,
737 ULARGE_INTEGER libOffset, /* [in] */
738 ULARGE_INTEGER cb, /* [in] */
739 DWORD dwLockType); /* [in] */
740
741HRESULT WINAPI StgStreamImpl_Stat(
742 IStream* iface,
743 STATSTG* pstatstg, /* [out] */
744 DWORD grfStatFlag); /* [in] */
745
746HRESULT WINAPI StgStreamImpl_Clone(
747 IStream* iface,
748 IStream** ppstm); /* [out] */
749
750
751/********************************************************************************
752 * The StorageUtl_ functions are miscelaneous utility functions. Most of which are
753 * abstractions used to read values from file buffers without having to worry
754 * about bit order
755 */
756void StorageUtl_ReadWord(void* buffer, ULONG offset, WORD* value);
757void StorageUtl_WriteWord(void* buffer, ULONG offset, WORD value);
758void StorageUtl_ReadDWord(void* buffer, ULONG offset, DWORD* value);
759void StorageUtl_WriteDWord(void* buffer, ULONG offset, DWORD value);
760void StorageUtl_ReadGUID(void* buffer, ULONG offset, GUID* value);
761void StorageUtl_WriteGUID(void* buffer, ULONG offset, GUID* value);
762void StorageUtl_CopyPropertyToSTATSTG(STATSTG* destination,
763 StgProperty* source,
764 int statFlags);
765
766/****************************************************************************
767 * BlockChainStream definitions.
768 *
769 * The BlockChainStream class is a utility class that is used to create an
770 * abstraction of the big block chains in the storage file.
771 */
772struct BlockChainStream
773{
774 StorageImpl* parentStorage;
775 ULONG* headOfStreamPlaceHolder;
776 ULONG ownerPropertyIndex;
777 ULONG lastBlockNoInSequence;
778 ULONG lastBlockNoInSequenceIndex;
779 ULONG tailIndex;
780 ULONG numBlocks;
781};
782
783/*
784 * Methods for the BlockChainStream class.
785 */
786BlockChainStream* BlockChainStream_Construct(
787 StorageImpl* parentStorage,
788 ULONG* headOfStreamPlaceHolder,
789 ULONG propertyIndex);
790
791void BlockChainStream_Destroy(
792 BlockChainStream* This);
793
794ULONG BlockChainStream_GetHeadOfChain(
795 BlockChainStream* This);
796
797BOOL BlockChainStream_ReadAt(
798 BlockChainStream* This,
799 ULARGE_INTEGER offset,
800 ULONG size,
801 void* buffer,
802 ULONG* bytesRead);
803
804BOOL BlockChainStream_WriteAt(
805 BlockChainStream* This,
806 ULARGE_INTEGER offset,
807 ULONG size,
808 const void* buffer,
809 ULONG* bytesWritten);
810
811BOOL BlockChainStream_SetSize(
812 BlockChainStream* This,
813 ULARGE_INTEGER newSize);
814
815ULARGE_INTEGER BlockChainStream_GetSize(
816 BlockChainStream* This);
817
818ULONG BlockChainStream_GetCount(
819 BlockChainStream* This);
820
821/****************************************************************************
822 * SmallBlockChainStream definitions.
823 *
824 * The SmallBlockChainStream class is a utility class that is used to create an
825 * abstraction of the small block chains in the storage file.
826 */
827struct SmallBlockChainStream
828{
829 StorageImpl* parentStorage;
830 ULONG ownerPropertyIndex;
831};
832
833/*
834 * Methods of the SmallBlockChainStream class.
835 */
836SmallBlockChainStream* SmallBlockChainStream_Construct(
837 StorageImpl* parentStorage,
838 ULONG propertyIndex);
839
840void SmallBlockChainStream_Destroy(
841 SmallBlockChainStream* This);
842
843ULONG SmallBlockChainStream_GetHeadOfChain(
844 SmallBlockChainStream* This);
845
846ULONG SmallBlockChainStream_GetNextBlockInChain(
847 SmallBlockChainStream* This,
848 ULONG blockIndex);
849
850void SmallBlockChainStream_SetNextBlockInChain(
851 SmallBlockChainStream* This,
852 ULONG blockIndex,
853 ULONG nextBlock);
854
855void SmallBlockChainStream_FreeBlock(
856 SmallBlockChainStream* This,
857 ULONG blockIndex);
858
859ULONG SmallBlockChainStream_GetNextFreeBlock(
860 SmallBlockChainStream* This);
861
862BOOL SmallBlockChainStream_ReadAt(
863 SmallBlockChainStream* This,
864 ULARGE_INTEGER offset,
865 ULONG size,
866 void* buffer,
867 ULONG* bytesRead);
868
869BOOL SmallBlockChainStream_WriteAt(
870 SmallBlockChainStream* This,
871 ULARGE_INTEGER offset,
872 ULONG size,
873 const void* buffer,
874 ULONG* bytesWritten);
875
876BOOL SmallBlockChainStream_SetSize(
877 SmallBlockChainStream* This,
878 ULARGE_INTEGER newSize);
879
880ULARGE_INTEGER SmallBlockChainStream_GetSize(
881 SmallBlockChainStream* This);
882
883ULONG SmallBlockChainStream_GetCount(
884 SmallBlockChainStream* This);
885
886
887#endif /* __STORAGE32_H__ */
888
889
890
Note: See TracBrowser for help on using the repository browser.