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