dlls/ole32/storage32.h

   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  * Copyright 2010 Vincent Povirk for CodeWeavers
  15  *
  16  * This library is free software; you can redistribute it and/or
  17  * modify it under the terms of the GNU Lesser General Public
  18  * License as published by the Free Software Foundation; either
  19  * version 2.1 of the License, or (at your option) any later version.
  20  *
  21  * This library is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  24  * Lesser General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU Lesser General Public
  27  * License along with this library; if not, write to the Free Software
  28  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  29  */
  30 #ifndef __STORAGE32_H__
  31 #define __STORAGE32_H__
  32
  33 #include <stdarg.h>
  34
  35 #include "windef.h"
  36 #include "winbase.h"
  37 #include "winnt.h"
  38 #include "objbase.h"
  39 #include "winreg.h"
  40 #include "winternl.h"
  41 #include "wine/list.h"
  42
  43 /*
  44  * Definitions for the file format offsets.
  45  */
  46 static const ULONG OFFSET_MINORVERSION       = 0x00000018;
  47 static const ULONG OFFSET_MAJORVERSION       = 0x0000001a;
  48 static const ULONG OFFSET_BYTEORDERMARKER    = 0x0000001c;
  49 static const ULONG OFFSET_BIGBLOCKSIZEBITS   = 0x0000001e;
  50 static const ULONG OFFSET_SMALLBLOCKSIZEBITS = 0x00000020;
  51 static const ULONG OFFSET_DIRSECTORCOUNT     = 0x00000028;
  52 static const ULONG OFFSET_BBDEPOTCOUNT       = 0x0000002C;
  53 static const ULONG OFFSET_ROOTSTARTBLOCK     = 0x00000030;
  54 static const ULONG OFFSET_SMALLBLOCKLIMIT    = 0x00000038;
  55 static const ULONG OFFSET_SBDEPOTSTART       = 0x0000003C;
  56 static const ULONG OFFSET_SBDEPOTCOUNT       = 0x00000040;
  57 static const ULONG OFFSET_EXTBBDEPOTSTART    = 0x00000044;
  58 static const ULONG OFFSET_EXTBBDEPOTCOUNT    = 0x00000048;
  59 static const ULONG OFFSET_BBDEPOTSTART       = 0x0000004C;
  60 static const ULONG OFFSET_PS_NAME            = 0x00000000;
  61 static const ULONG OFFSET_PS_NAMELENGTH      = 0x00000040;
  62 static const ULONG OFFSET_PS_STGTYPE         = 0x00000042;
  63 static const ULONG OFFSET_PS_LEFTCHILD       = 0x00000044;
  64 static const ULONG OFFSET_PS_RIGHTCHILD      = 0x00000048;
  65 static const ULONG OFFSET_PS_DIRROOT         = 0x0000004C;
  66 static const ULONG OFFSET_PS_GUID            = 0x00000050;
  67 static const ULONG OFFSET_PS_CTIMELOW        = 0x00000064;
  68 static const ULONG OFFSET_PS_CTIMEHIGH       = 0x00000068;
  69 static const ULONG OFFSET_PS_MTIMELOW        = 0x0000006C;
  70 static const ULONG OFFSET_PS_MTIMEHIGH       = 0x00000070;
  71 static const ULONG OFFSET_PS_STARTBLOCK      = 0x00000074;
  72 static const ULONG OFFSET_PS_SIZE            = 0x00000078;
  73 static const WORD  DEF_BIG_BLOCK_SIZE_BITS   = 0x0009;
  74 static const WORD  MIN_BIG_BLOCK_SIZE_BITS   = 0x0009;
  75 static const WORD  MAX_BIG_BLOCK_SIZE_BITS   = 0x000c;
  76 static const WORD  DEF_SMALL_BLOCK_SIZE_BITS = 0x0006;
  77 static const WORD  DEF_BIG_BLOCK_SIZE        = 0x0200;
  78 static const WORD  DEF_SMALL_BLOCK_SIZE      = 0x0040;
  79 static const ULONG BLOCK_EXTBBDEPOT          = 0xFFFFFFFC;
  80 static const ULONG BLOCK_SPECIAL             = 0xFFFFFFFD;
  81 static const ULONG BLOCK_END_OF_CHAIN        = 0xFFFFFFFE;
  82 static const ULONG BLOCK_UNUSED              = 0xFFFFFFFF;
  83 static const ULONG DIRENTRY_NULL             = 0xFFFFFFFF;
  84
  85 #define DIRENTRY_NAME_MAX_LEN    0x20
  86 #define DIRENTRY_NAME_BUFFER_LEN 0x40
  87
  88 #define RAW_DIRENTRY_SIZE 0x00000080
  89
  90 #define HEADER_SIZE 512
  91
  92 #define MIN_BIG_BLOCK_SIZE 0x200
  93 #define MAX_BIG_BLOCK_SIZE 0x1000
  94
  95 /*
  96  * Type of child entry link
  97  */
  98 #define DIRENTRY_RELATION_PREVIOUS 0
  99 #define DIRENTRY_RELATION_NEXT     1
 100 #define DIRENTRY_RELATION_DIR      2
 101
 102 /*
 103  * type constant used in files for the root storage
 104  */
 105 #define STGTY_ROOT 0x05
 106
 107 #define COUNT_BBDEPOTINHEADER    109
 108
 109 /* FIXME: This value is stored in the header, but we hard-code it to 0x1000. */
 110 #define LIMIT_TO_USE_SMALL_BLOCK 0x1000
 111
 112 #define STGM_ACCESS_MODE(stgm)   ((stgm)&0x0000f)
 113 #define STGM_SHARE_MODE(stgm)    ((stgm)&0x000f0)
 114 #define STGM_CREATE_MODE(stgm)   ((stgm)&0x0f000)
 115
 116 #define STGM_KNOWN_FLAGS (0xf0ff | \
 117      STGM_TRANSACTED | STGM_CONVERT | STGM_PRIORITY | STGM_NOSCRATCH | \
 118      STGM_NOSNAPSHOT | STGM_DIRECT_SWMR | STGM_DELETEONRELEASE | STGM_SIMPLE)
 119
 120 /*
 121  * Forward declarations of all the structures used by the storage
 122  * module.
 123  */
 124 typedef struct StorageBaseImpl     StorageBaseImpl;
 125 typedef struct StorageBaseImplVtbl StorageBaseImplVtbl;
 126 typedef struct StorageImpl         StorageImpl;
 127 typedef struct BlockChainStream      BlockChainStream;
 128 typedef struct SmallBlockChainStream SmallBlockChainStream;
 129 typedef struct IEnumSTATSTGImpl      IEnumSTATSTGImpl;
 130 typedef struct DirEntry              DirEntry;
 131 typedef struct StgStreamImpl         StgStreamImpl;
 132
 133 /*
 134  * A reference to a directory entry in the file or a transacted cache.
 135  */
 136 typedef ULONG DirRef;
 137
 138 /*
 139  * This utility structure is used to read/write the information in a directory
 140  * entry.
 141  */
 142 struct DirEntry
 143 {
 144   WCHAR          name[DIRENTRY_NAME_MAX_LEN];
 145   WORD           sizeOfNameString;
 146   BYTE           stgType;
 147   DirRef         leftChild;
 148   DirRef         rightChild;
 149   DirRef         dirRootEntry;
 150   GUID           clsid;
 151   FILETIME       ctime;
 152   FILETIME       mtime;
 153   ULONG          startingBlock;
 154   ULARGE_INTEGER size;
 155 };
 156
 157 HRESULT FileLockBytesImpl_Construct(HANDLE hFile, DWORD openFlags, LPCWSTR pwcsName, ILockBytes **pLockBytes) DECLSPEC_HIDDEN;
 158
 159 /*************************************************************************
 160  * Ole Convert support
 161  */
 162
 163 HRESULT STORAGE_CreateOleStream(IStorage*, DWORD) DECLSPEC_HIDDEN;
 164 HRESULT OLECONVERT_CreateCompObjStream(LPSTORAGE pStorage, LPCSTR strOleTypeName) DECLSPEC_HIDDEN;
 165
 166 enum swmr_mode
 167 {
 168   SWMR_None,
 169   SWMR_Writer,
 170   SWMR_Reader
 171 };
 172
 173 /****************************************************************************
 174  * StorageBaseImpl definitions.
 175  *
 176  * This structure defines the base information contained in all implementations
 177  * of IStorage contained in this file storage implementation.
 178  *
 179  * In OOP terms, this is the base class for all the IStorage implementations
 180  * contained in this file.
 181  */
 182 struct StorageBaseImpl
 183 {
 184   IStorage IStorage_iface;
 185   IPropertySetStorage IPropertySetStorage_iface; /* interface for adding a properties stream */
 186   IDirectWriterLock IDirectWriterLock_iface;
 187   LONG ref;
 188
 189   /*
 190    * Stream tracking list
 191    */
 192
 193   struct list strmHead;
 194
 195   /*
 196    * Storage tracking list
 197    */
 198   struct list storageHead;
 199
 200   /*
 201    * TRUE if this object has been invalidated
 202    */
 203   BOOL reverted;
 204
 205   /*
 206    * Index of the directory entry of this storage
 207    */
 208   DirRef storageDirEntry;
 209
 210   /*
 211    * virtual methods.
 212    */
 213   const StorageBaseImplVtbl *baseVtbl;
 214
 215   /*
 216    * flags that this storage was opened or created with
 217    */
 218   DWORD openFlags;
 219
 220   /*
 221    * State bits appear to only be preserved while running. No in the stream
 222    */
 223   DWORD stateBits;
 224
 225   BOOL  create;     /* Was the storage created or opened.
 226                        The behaviour of STGM_SIMPLE depends on this */
 227   /*
 228    * If this storage was opened in transacted mode, the object that implements
 229    * the transacted snapshot or cache.
 230    */
 231   StorageBaseImpl *transactedChild;
 232   enum swmr_mode lockingrole;
 233 };
 234
 235 /* virtual methods for StorageBaseImpl objects */
 236 struct StorageBaseImplVtbl {
 237   void (*Destroy)(StorageBaseImpl*);
 238   void (*Invalidate)(StorageBaseImpl*);
 239   HRESULT (*Flush)(StorageBaseImpl*);
 240   HRESULT (*GetFilename)(StorageBaseImpl*,LPWSTR*);
 241   HRESULT (*CreateDirEntry)(StorageBaseImpl*,const DirEntry*,DirRef*);
 242   HRESULT (*WriteDirEntry)(StorageBaseImpl*,DirRef,const DirEntry*);
 243   HRESULT (*ReadDirEntry)(StorageBaseImpl*,DirRef,DirEntry*);
 244   HRESULT (*DestroyDirEntry)(StorageBaseImpl*,DirRef);
 245   HRESULT (*StreamReadAt)(StorageBaseImpl*,DirRef,ULARGE_INTEGER,ULONG,void*,ULONG*);
 246   HRESULT (*StreamWriteAt)(StorageBaseImpl*,DirRef,ULARGE_INTEGER,ULONG,const void*,ULONG*);
 247   HRESULT (*StreamSetSize)(StorageBaseImpl*,DirRef,ULARGE_INTEGER);
 248   HRESULT (*StreamLink)(StorageBaseImpl*,DirRef,DirRef);
 249 };
 250
 251 static inline void StorageBaseImpl_Destroy(StorageBaseImpl *This)
 252 {
 253   This->baseVtbl->Destroy(This);
 254 }
 255
 256 static inline void StorageBaseImpl_Invalidate(StorageBaseImpl *This)
 257 {
 258   This->baseVtbl->Invalidate(This);
 259 }
 260
 261 static inline HRESULT StorageBaseImpl_Flush(StorageBaseImpl *This)
 262 {
 263   return This->baseVtbl->Flush(This);
 264 }
 265
 266 static inline HRESULT StorageBaseImpl_GetFilename(StorageBaseImpl *This, LPWSTR *result)
 267 {
 268   return This->baseVtbl->GetFilename(This, result);
 269 }
 270
 271 static inline HRESULT StorageBaseImpl_CreateDirEntry(StorageBaseImpl *This,
 272   const DirEntry *newData, DirRef *index)
 273 {
 274   return This->baseVtbl->CreateDirEntry(This, newData, index);
 275 }
 276
 277 static inline HRESULT StorageBaseImpl_WriteDirEntry(StorageBaseImpl *This,
 278   DirRef index, const DirEntry *data)
 279 {
 280   return This->baseVtbl->WriteDirEntry(This, index, data);
 281 }
 282
 283 static inline HRESULT StorageBaseImpl_ReadDirEntry(StorageBaseImpl *This,
 284   DirRef index, DirEntry *data)
 285 {
 286   return This->baseVtbl->ReadDirEntry(This, index, data);
 287 }
 288
 289 static inline HRESULT StorageBaseImpl_DestroyDirEntry(StorageBaseImpl *This,
 290   DirRef index)
 291 {
 292   return This->baseVtbl->DestroyDirEntry(This, index);
 293 }
 294
 295 /* Read up to size bytes from this directory entry's stream at the given offset. */
 296 static inline HRESULT StorageBaseImpl_StreamReadAt(StorageBaseImpl *This,
 297   DirRef index, ULARGE_INTEGER offset, ULONG size, void *buffer, ULONG *bytesRead)
 298 {
 299   return This->baseVtbl->StreamReadAt(This, index, offset, size, buffer, bytesRead);
 300 }
 301
 302 /* Write size bytes to this directory entry's stream at the given offset,
 303  * growing the stream if necessary. */
 304 static inline HRESULT StorageBaseImpl_StreamWriteAt(StorageBaseImpl *This,
 305   DirRef index, ULARGE_INTEGER offset, ULONG size, const void *buffer, ULONG *bytesWritten)
 306 {
 307   return This->baseVtbl->StreamWriteAt(This, index, offset, size, buffer, bytesWritten);
 308 }
 309
 310 static inline HRESULT StorageBaseImpl_StreamSetSize(StorageBaseImpl *This,
 311   DirRef index, ULARGE_INTEGER newsize)
 312 {
 313   return This->baseVtbl->StreamSetSize(This, index, newsize);
 314 }
 315
 316 /* Make dst point to the same stream that src points to. Other stream operations
 317  * will not work properly for entries that point to the same stream, so this
 318  * must be a very temporary state, and only one entry pointing to a given stream
 319  * may be reachable at any given time. */
 320 static inline HRESULT StorageBaseImpl_StreamLink(StorageBaseImpl *This,
 321   DirRef dst, DirRef src)
 322 {
 323   return This->baseVtbl->StreamLink(This, dst, src);
 324 }
 325
 326 /****************************************************************************
 327  * StorageBaseImpl stream list handlers
 328  */
 329
 330 void StorageBaseImpl_AddStream(StorageBaseImpl * stg, StgStreamImpl * strm) DECLSPEC_HIDDEN;
 331 void StorageBaseImpl_RemoveStream(StorageBaseImpl * stg, StgStreamImpl * strm) DECLSPEC_HIDDEN;
 332
 333 /* Number of BlockChainStream objects to cache in a StorageImpl */
 334 #define BLOCKCHAIN_CACHE_SIZE 4
 335
 336 /****************************************************************************
 337  * Storage32Impl definitions.
 338  *
 339  * This implementation of the IStorage32 interface represents a root
 340  * storage. Basically, a document file.
 341  */
 342 struct StorageImpl
 343 {
 344   struct StorageBaseImpl base;
 345
 346   /*
 347    * File header
 348    */
 349   WORD  bigBlockSizeBits;
 350   WORD  smallBlockSizeBits;
 351   ULONG bigBlockSize;
 352   ULONG smallBlockSize;
 353   ULONG bigBlockDepotCount;
 354   ULONG rootStartBlock;
 355   ULONG smallBlockLimit;
 356   ULONG smallBlockDepotStart;
 357   ULONG extBigBlockDepotStart;
 358   ULONG *extBigBlockDepotLocations;
 359   ULONG extBigBlockDepotLocationsSize;
 360   ULONG extBigBlockDepotCount;
 361   ULONG bigBlockDepotStart[COUNT_BBDEPOTINHEADER];
 362
 363   ULONG extBlockDepotCached[MAX_BIG_BLOCK_SIZE / 4];
 364   ULONG indexExtBlockDepotCached;
 365
 366   ULONG blockDepotCached[MAX_BIG_BLOCK_SIZE / 4];
 367   ULONG indexBlockDepotCached;
 368   ULONG prevFreeBlock;
 369
 370   /* All small blocks before this one are known to be in use. */
 371   ULONG firstFreeSmallBlock;
 372
 373   /*
 374    * Abstraction of the big block chains for the chains of the header.
 375    */
 376   BlockChainStream* rootBlockChain;
 377   BlockChainStream* smallBlockDepotChain;
 378   BlockChainStream* smallBlockRootChain;
 379
 380   /* Cache of block chain streams objects for directory entries */
 381   BlockChainStream* blockChainCache[BLOCKCHAIN_CACHE_SIZE];
 382   UINT blockChainToEvict;
 383
 384   ILockBytes* lockBytes;
 385 };
 386
 387 HRESULT StorageImpl_ReadRawDirEntry(
 388             StorageImpl *This,
 389             ULONG index,
 390             BYTE *buffer) DECLSPEC_HIDDEN;
 391
 392 void UpdateRawDirEntry(
 393     BYTE *buffer,
 394     const DirEntry *newData) DECLSPEC_HIDDEN;
 395
 396 HRESULT StorageImpl_WriteRawDirEntry(
 397             StorageImpl *This,
 398             ULONG index,
 399             const BYTE *buffer) DECLSPEC_HIDDEN;
 400
 401 HRESULT StorageImpl_ReadDirEntry(
 402             StorageImpl*    This,
 403             DirRef          index,
 404             DirEntry*       buffer) DECLSPEC_HIDDEN;
 405
 406 HRESULT StorageImpl_WriteDirEntry(
 407             StorageImpl*        This,
 408             DirRef              index,
 409             const DirEntry*     buffer) DECLSPEC_HIDDEN;
 410
 411 BlockChainStream* Storage32Impl_SmallBlocksToBigBlocks(
 412                       StorageImpl* This,
 413                       SmallBlockChainStream** ppsbChain) DECLSPEC_HIDDEN;
 414
 415 SmallBlockChainStream* Storage32Impl_BigBlocksToSmallBlocks(
 416                       StorageImpl* This,
 417                       BlockChainStream** ppbbChain,
 418                       ULARGE_INTEGER newSize) DECLSPEC_HIDDEN;
 419
 420 /****************************************************************************
 421  * StgStreamImpl definitions.
 422  *
 423  * This class implements the IStream interface and represents a stream
 424  * located inside a storage object.
 425  */
 426 struct StgStreamImpl
 427 {
 428   IStream IStream_iface;
 429   LONG ref;
 430
 431   /*
 432    * We are an entry in the storage object's stream handler list
 433    */
 434   struct list StrmListEntry;
 435
 436   /*
 437    * Storage that is the parent(owner) of the stream
 438    */
 439   StorageBaseImpl* parentStorage;
 440
 441   /*
 442    * Access mode of this stream.
 443    */
 444   DWORD grfMode;
 445
 446   /*
 447    * Index of the directory entry that owns (points to) this stream.
 448    */
 449   DirRef             dirEntry;
 450
 451   /*
 452    * This is the current position of the cursor in the stream
 453    */
 454   ULARGE_INTEGER     currentPosition;
 455 };
 456
 457 static inline StgStreamImpl *impl_from_IStream( IStream *iface )
 458 {
 459     return CONTAINING_RECORD(iface, StgStreamImpl, IStream_iface);
 460 }
 461
 462 /*
 463  * Method definition for the StgStreamImpl class.
 464  */
 465 StgStreamImpl* StgStreamImpl_Construct(
 466                 StorageBaseImpl* parentStorage,
 467     DWORD            grfMode,
 468     DirRef           dirEntry) DECLSPEC_HIDDEN;
 469
 470
 471 /******************************************************************************
 472  * Endian conversion macros
 473  */
 474 #ifdef WORDS_BIGENDIAN
 475
 476 #define htole32(x) RtlUlongByteSwap(x)
 477 #define htole16(x) RtlUshortByteSwap(x)
 478 #define lendian32toh(x) RtlUlongByteSwap(x)
 479 #define lendian16toh(x) RtlUshortByteSwap(x)
 480
 481 #else
 482
 483 #define htole32(x) (x)
 484 #define htole16(x) (x)
 485 #define lendian32toh(x) (x)
 486 #define lendian16toh(x) (x)
 487
 488 #endif
 489
 490 /******************************************************************************
 491  * The StorageUtl_ functions are miscellaneous utility functions. Most of which
 492  * are abstractions used to read values from file buffers without having to
 493  * worry about bit order
 494  */
 495 void StorageUtl_ReadWord(const BYTE* buffer, ULONG offset, WORD* value) DECLSPEC_HIDDEN;
 496 void StorageUtl_WriteWord(BYTE* buffer, ULONG offset, WORD value) DECLSPEC_HIDDEN;
 497 void StorageUtl_ReadDWord(const BYTE* buffer, ULONG offset, DWORD* value) DECLSPEC_HIDDEN;
 498 void StorageUtl_WriteDWord(BYTE* buffer, ULONG offset, DWORD value) DECLSPEC_HIDDEN;
 499 void StorageUtl_ReadULargeInteger(const BYTE* buffer, ULONG offset,
 500  ULARGE_INTEGER* value) DECLSPEC_HIDDEN;
 501 void StorageUtl_WriteULargeInteger(BYTE* buffer, ULONG offset,
 502  const ULARGE_INTEGER *value) DECLSPEC_HIDDEN;
 503 void StorageUtl_ReadGUID(const BYTE* buffer, ULONG offset, GUID* value) DECLSPEC_HIDDEN;
 504 void StorageUtl_WriteGUID(BYTE* buffer, ULONG offset, const GUID* value) DECLSPEC_HIDDEN;
 505 void StorageUtl_CopyDirEntryToSTATSTG(StorageBaseImpl *storage,STATSTG* destination,
 506  const DirEntry* source, int statFlags) DECLSPEC_HIDDEN;
 507
 508 /****************************************************************************
 509  * BlockChainStream definitions.
 510  *
 511  * The BlockChainStream class is a utility class that is used to create an
 512  * abstraction of the big block chains in the storage file.
 513  */
 514 struct BlockChainRun
 515 {
 516   /* This represents a range of blocks that happen reside in consecutive sectors. */
 517   ULONG firstSector;
 518   ULONG firstOffset;
 519   ULONG lastOffset;
 520 };
 521
 522 typedef struct BlockChainBlock
 523 {
 524   ULONG index;
 525   ULONG sector;
 526   BOOL  read;
 527   BOOL  dirty;
 528   BYTE data[MAX_BIG_BLOCK_SIZE];
 529 } BlockChainBlock;
 530
 531 struct BlockChainStream
 532 {
 533   StorageImpl* parentStorage;
 534   ULONG*       headOfStreamPlaceHolder;
 535   DirRef       ownerDirEntry;
 536   struct BlockChainRun* indexCache;
 537   ULONG        indexCacheLen;
 538   ULONG        indexCacheSize;
 539   BlockChainBlock cachedBlocks[2];
 540   ULONG        blockToEvict;
 541   ULONG        tailIndex;
 542   ULONG        numBlocks;
 543 };
 544
 545 /*
 546  * Methods for the BlockChainStream class.
 547  */
 548 BlockChainStream* BlockChainStream_Construct(
 549                 StorageImpl* parentStorage,
 550                 ULONG*         headOfStreamPlaceHolder,
 551                 DirRef         dirEntry) DECLSPEC_HIDDEN;
 552
 553 void BlockChainStream_Destroy(
 554                 BlockChainStream* This) DECLSPEC_HIDDEN;
 555
 556 HRESULT BlockChainStream_ReadAt(
 557                 BlockChainStream* This,
 558                 ULARGE_INTEGER offset,
 559                 ULONG          size,
 560                 void*          buffer,
 561                 ULONG*         bytesRead) DECLSPEC_HIDDEN;
 562
 563 HRESULT BlockChainStream_WriteAt(
 564                 BlockChainStream* This,
 565                 ULARGE_INTEGER offset,
 566                 ULONG          size,
 567                 const void*    buffer,
 568                 ULONG*         bytesWritten) DECLSPEC_HIDDEN;
 569
 570 BOOL BlockChainStream_SetSize(
 571                 BlockChainStream* This,
 572                 ULARGE_INTEGER    newSize) DECLSPEC_HIDDEN;
 573
 574 HRESULT BlockChainStream_Flush(
 575                 BlockChainStream* This) DECLSPEC_HIDDEN;
 576
 577 /****************************************************************************
 578  * SmallBlockChainStream definitions.
 579  *
 580  * The SmallBlockChainStream class is a utility class that is used to create an
 581  * abstraction of the small block chains in the storage file.
 582  */
 583 struct SmallBlockChainStream
 584 {
 585   StorageImpl* parentStorage;
 586   DirRef         ownerDirEntry;
 587   ULONG*         headOfStreamPlaceHolder;
 588 };
 589
 590 /*
 591  * Methods of the SmallBlockChainStream class.
 592  */
 593 SmallBlockChainStream* SmallBlockChainStream_Construct(
 594            StorageImpl*   parentStorage,
 595            ULONG*         headOfStreamPlaceHolder,
 596            DirRef         dirEntry) DECLSPEC_HIDDEN;
 597
 598 void SmallBlockChainStream_Destroy(
 599                SmallBlockChainStream* This) DECLSPEC_HIDDEN;
 600
 601 HRESULT SmallBlockChainStream_ReadAt(
 602                SmallBlockChainStream* This,
 603                ULARGE_INTEGER offset,
 604                ULONG          size,
 605                void*          buffer,
 606                ULONG*         bytesRead) DECLSPEC_HIDDEN;
 607
 608 HRESULT SmallBlockChainStream_WriteAt(
 609                SmallBlockChainStream* This,
 610                ULARGE_INTEGER offset,
 611                ULONG          size,
 612                const void*    buffer,
 613                ULONG*         bytesWritten) DECLSPEC_HIDDEN;
 614
 615 BOOL SmallBlockChainStream_SetSize(
 616                SmallBlockChainStream* This,
 617                ULARGE_INTEGER          newSize) DECLSPEC_HIDDEN;
 618
 619
 620 #endif /* __STORAGE32_H__ */