git.oblomov.eu Git - wine/blob - dlls/ole32/storage32.c

   1 /*
   2  * Compound Storage (32 bit version)
   3  * Storage implementation
   4  *
   5  * This file contains the compound file implementation
   6  * of the storage interface.
   7  *
   8  * Copyright 1999 Francis Beaudet
   9  * Copyright 1999 Sylvain St-Germain
  10  * Copyright 1999 Thuy Nguyen
  11  * Copyright 2005 Mike McCormack
  12  *
  13  * This library is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU Lesser General Public
  15  * License as published by the Free Software Foundation; either
  16  * version 2.1 of the License, or (at your option) any later version.
  17  *
  18  * This library is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21  * Lesser General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU Lesser General Public
  24  * License along with this library; if not, write to the Free Software
  25  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  26  *
  27  * NOTES
  28  *  The compound file implementation of IStorage used for create
  29  *  and manage substorages and streams within a storage object
  30  *  residing in a compound file object.
  31  */
  32
  33 #include <assert.h>
  34 #include <stdarg.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38
  39 #define COBJMACROS
  40 #define NONAMELESSUNION
  41 #define NONAMELESSSTRUCT
  42
  43 #include "windef.h"
  44 #include "winbase.h"
  45 #include "winnls.h"
  46 #include "winuser.h"
  47 #include "wine/unicode.h"
  48 #include "wine/debug.h"
  49
  50 #include "storage32.h"
  51 #include "ole2.h"      /* For Write/ReadClassStm */
  52
  53 #include "winreg.h"
  54 #include "wine/wingdi16.h"
  55
  56 WINE_DEFAULT_DEBUG_CHANNEL(storage);
  57
  58 /* Used for OleConvertIStorageToOLESTREAM and OleConvertOLESTREAMToIStorage */
  59 #define OLESTREAM_ID 0x501
  60 #define OLESTREAM_MAX_STR_LEN 255
  61
  62 /*
  63  * These are signatures to detect the type of Document file.
  64  */
  65 static const BYTE STORAGE_magic[8]    ={0xd0,0xcf,0x11,0xe0,0xa1,0xb1,0x1a,0xe1};
  66 static const BYTE STORAGE_oldmagic[8] ={0xd0,0xcf,0x11,0xe0,0x0e,0x11,0xfc,0x0d};
  67
  68 static const char rootEntryName[] = "Root Entry";
  69
  70 /****************************************************************************
  71  * Storage32InternalImpl definitions.
  72  *
  73  * Definition of the implementation structure for the IStorage32 interface.
  74  * This one implements the IStorage32 interface for storage that are
  75  * inside another storage.
  76  */
  77 struct StorageInternalImpl
  78 {
  79   struct StorageBaseImpl base;
  80
  81   /*
  82    * Entry in the parent's stream tracking list
  83    */
  84   struct list ParentListEntry;
  85
  86   StorageBaseImpl *parentStorage;
  87 };
  88 typedef struct StorageInternalImpl StorageInternalImpl;
  89
  90 /* Method definitions for the Storage32InternalImpl class. */
  91 static StorageInternalImpl* StorageInternalImpl_Construct(StorageBaseImpl* parentStorage,
  92                                                           DWORD openFlags, DirRef storageDirEntry);
  93 static void StorageImpl_Destroy(StorageBaseImpl* iface);
  94 static void StorageImpl_Invalidate(StorageBaseImpl* iface);
  95 static BOOL StorageImpl_ReadBigBlock(StorageImpl* This, ULONG blockIndex, void* buffer);
  96 static BOOL StorageImpl_WriteBigBlock(StorageImpl* This, ULONG blockIndex, const void* buffer);
  97 static void StorageImpl_SetNextBlockInChain(StorageImpl* This, ULONG blockIndex, ULONG nextBlock);
  98 static HRESULT StorageImpl_LoadFileHeader(StorageImpl* This);
  99 static void StorageImpl_SaveFileHeader(StorageImpl* This);
 100
 101 static void Storage32Impl_AddBlockDepot(StorageImpl* This, ULONG blockIndex);
 102 static ULONG Storage32Impl_AddExtBlockDepot(StorageImpl* This);
 103 static ULONG Storage32Impl_GetNextExtendedBlock(StorageImpl* This, ULONG blockIndex);
 104 static ULONG Storage32Impl_GetExtDepotBlock(StorageImpl* This, ULONG depotIndex);
 105 static void Storage32Impl_SetExtDepotBlock(StorageImpl* This, ULONG depotIndex, ULONG blockIndex);
 106
 107 static ULONG BlockChainStream_GetHeadOfChain(BlockChainStream* This);
 108 static ULARGE_INTEGER BlockChainStream_GetSize(BlockChainStream* This);
 109 static ULONG BlockChainStream_GetCount(BlockChainStream* This);
 110
 111 static ULARGE_INTEGER SmallBlockChainStream_GetSize(SmallBlockChainStream* This);
 112 static ULONG SmallBlockChainStream_GetHeadOfChain(SmallBlockChainStream* This);
 113 static BOOL StorageImpl_WriteDWordToBigBlock( StorageImpl* This,
 114     ULONG blockIndex, ULONG offset, DWORD value);
 115 static BOOL StorageImpl_ReadDWordFromBigBlock( StorageImpl*  This,
 116     ULONG blockIndex, ULONG offset, DWORD* value);
 117
 118 static BOOL StorageBaseImpl_IsStreamOpen(StorageBaseImpl * stg, DirRef streamEntry);
 119 static BOOL StorageBaseImpl_IsStorageOpen(StorageBaseImpl * stg, DirRef storageEntry);
 120
 121 /****************************************************************************
 122  * Transacted storage object that reads/writes a snapshot file.
 123  */
 124 typedef struct TransactedSnapshotImpl
 125 {
 126   struct StorageBaseImpl base;
 127
 128   /*
 129    * Changes are temporarily saved to the snapshot.
 130    */
 131   StorageBaseImpl *snapshot;
 132
 133   /*
 134    * Changes are committed to the transacted parent.
 135    */
 136   StorageBaseImpl *transactedParent;
 137 } TransactedSnapshotImpl;
 138
 139 /* Generic function to create a transacted wrapper for a direct storage object. */
 140 static HRESULT Storage_ConstructTransacted(StorageBaseImpl* parent, StorageBaseImpl** result);
 141
 142 /* OLESTREAM memory structure to use for Get and Put Routines */
 143 /* Used for OleConvertIStorageToOLESTREAM and OleConvertOLESTREAMToIStorage */
 144 typedef struct
 145 {
 146     DWORD dwOleID;
 147     DWORD dwTypeID;
 148     DWORD dwOleTypeNameLength;
 149     CHAR  strOleTypeName[OLESTREAM_MAX_STR_LEN];
 150     CHAR  *pstrOleObjFileName;
 151     DWORD dwOleObjFileNameLength;
 152     DWORD dwMetaFileWidth;
 153     DWORD dwMetaFileHeight;
 154     CHAR  strUnknown[8]; /* don't know what this 8 byte information in OLE stream is. */
 155     DWORD dwDataLength;
 156     BYTE *pData;
 157 }OLECONVERT_OLESTREAM_DATA;
 158
 159 /* CompObj Stream structure */
 160 /* Used for OleConvertIStorageToOLESTREAM and OleConvertOLESTREAMToIStorage */
 161 typedef struct
 162 {
 163     BYTE byUnknown1[12];
 164     CLSID clsid;
 165     DWORD dwCLSIDNameLength;
 166     CHAR strCLSIDName[OLESTREAM_MAX_STR_LEN];
 167     DWORD dwOleTypeNameLength;
 168     CHAR strOleTypeName[OLESTREAM_MAX_STR_LEN];
 169     DWORD dwProgIDNameLength;
 170     CHAR strProgIDName[OLESTREAM_MAX_STR_LEN];
 171     BYTE byUnknown2[16];
 172 }OLECONVERT_ISTORAGE_COMPOBJ;
 173
 174
 175 /* Ole Presentation Stream structure */
 176 /* Used for OleConvertIStorageToOLESTREAM and OleConvertOLESTREAMToIStorage */
 177 typedef struct
 178 {
 179     BYTE byUnknown1[28];
 180     DWORD dwExtentX;
 181     DWORD dwExtentY;
 182     DWORD dwSize;
 183     BYTE *pData;
 184 }OLECONVERT_ISTORAGE_OLEPRES;
 185
 186
 187
 188 /***********************************************************************
 189  * Forward declaration of internal functions used by the method DestroyElement
 190  */
 191 static HRESULT deleteStorageContents(
 192   StorageBaseImpl *parentStorage,
 193   DirRef       indexToDelete,
 194   DirEntry     entryDataToDelete);
 195
 196 static HRESULT deleteStreamContents(
 197   StorageBaseImpl *parentStorage,
 198   DirRef        indexToDelete,
 199   DirEntry      entryDataToDelete);
 200
 201 static HRESULT removeFromTree(
 202   StorageBaseImpl *This,
 203   DirRef        parentStorageIndex,
 204   DirRef        deletedIndex);
 205
 206 /***********************************************************************
 207  * Declaration of the functions used to manipulate DirEntry
 208  */
 209
 210 static HRESULT insertIntoTree(
 211   StorageBaseImpl *This,
 212   DirRef        parentStorageIndex,
 213   DirRef        newEntryIndex);
 214
 215 static LONG entryNameCmp(
 216     const OLECHAR *name1,
 217     const OLECHAR *name2);
 218
 219 static DirRef findElement(
 220     StorageBaseImpl *storage,
 221     DirRef storageEntry,
 222     const OLECHAR *name,
 223     DirEntry *data);
 224
 225 static HRESULT findTreeParent(
 226     StorageBaseImpl *storage,
 227     DirRef storageEntry,
 228     const OLECHAR *childName,
 229     DirEntry *parentData,
 230     DirRef *parentEntry,
 231     ULONG *relation);
 232
 233 /***********************************************************************
 234  * Declaration of miscellaneous functions...
 235  */
 236 static HRESULT validateSTGM(DWORD stgmValue);
 237
 238 static DWORD GetShareModeFromSTGM(DWORD stgm);
 239 static DWORD GetAccessModeFromSTGM(DWORD stgm);
 240 static DWORD GetCreationModeFromSTGM(DWORD stgm);
 241
 242 extern const IPropertySetStorageVtbl IPropertySetStorage_Vtbl;
 243
 244
 245 /****************************************************************************
 246  * IEnumSTATSTGImpl definitions.
 247  *
 248  * Definition of the implementation structure for the IEnumSTATSTGImpl interface.
 249  * This class allows iterating through the content of a storage and to find
 250  * specific items inside it.
 251  */
 252 struct IEnumSTATSTGImpl
 253 {
 254   const IEnumSTATSTGVtbl *lpVtbl;    /* Needs to be the first item in the struct
 255                                 * since we want to cast this in an IEnumSTATSTG pointer */
 256
 257   LONG           ref;                   /* Reference count */
 258   StorageBaseImpl* parentStorage;         /* Reference to the parent storage */
 259   DirRef         storageDirEntry;     /* Directory entry of the storage to enumerate */
 260
 261   WCHAR          name[DIRENTRY_NAME_MAX_LEN]; /* The most recent name visited */
 262 };
 263
 264
 265 static IEnumSTATSTGImpl* IEnumSTATSTGImpl_Construct(StorageBaseImpl* This, DirRef storageDirEntry);
 266 static void IEnumSTATSTGImpl_Destroy(IEnumSTATSTGImpl* This);
 267
 268 /************************************************************************
 269 ** Block Functions
 270 */
 271
 272 static ULONG StorageImpl_GetBigBlockOffset(StorageImpl* This, ULONG index)
 273 {
 274     return (index+1) * This->bigBlockSize;
 275 }
 276
 277 /************************************************************************
 278 ** Storage32BaseImpl implementation
 279 */
 280 static HRESULT StorageImpl_ReadAt(StorageImpl* This,
 281   ULARGE_INTEGER offset,
 282   void*          buffer,
 283   ULONG          size,
 284   ULONG*         bytesRead)
 285 {
 286     return BIGBLOCKFILE_ReadAt(This->bigBlockFile,offset,buffer,size,bytesRead);
 287 }
 288
 289 static HRESULT StorageImpl_WriteAt(StorageImpl* This,
 290   ULARGE_INTEGER offset,
 291   const void*    buffer,
 292   const ULONG    size,
 293   ULONG*         bytesWritten)
 294 {
 295     return BIGBLOCKFILE_WriteAt(This->bigBlockFile,offset,buffer,size,bytesWritten);
 296 }
 297
 298 /************************************************************************
 299  * Storage32BaseImpl_QueryInterface (IUnknown)
 300  *
 301  * This method implements the common QueryInterface for all IStorage32
 302  * implementations contained in this file.
 303  *
 304  * See Windows documentation for more details on IUnknown methods.
 305  */
 306 static HRESULT WINAPI StorageBaseImpl_QueryInterface(
 307   IStorage*        iface,
 308   REFIID             riid,
 309   void**             ppvObject)
 310 {
 311   StorageBaseImpl *This = (StorageBaseImpl *)iface;
 312
 313   if ( (This==0) || (ppvObject==0) )
 314     return E_INVALIDARG;
 315
 316   *ppvObject = 0;
 317
 318   if (IsEqualGUID(&IID_IUnknown, riid) ||
 319       IsEqualGUID(&IID_IStorage, riid))
 320   {
 321     *ppvObject = This;
 322   }
 323   else if (IsEqualGUID(&IID_IPropertySetStorage, riid))
 324   {
 325     *ppvObject = &This->pssVtbl;
 326   }
 327
 328   if ((*ppvObject)==0)
 329     return E_NOINTERFACE;
 330
 331   IStorage_AddRef(iface);
 332
 333   return S_OK;
 334 }
 335
 336 /************************************************************************
 337  * Storage32BaseImpl_AddRef (IUnknown)
 338  *
 339  * This method implements the common AddRef for all IStorage32
 340  * implementations contained in this file.
 341  *
 342  * See Windows documentation for more details on IUnknown methods.
 343  */
 344 static ULONG WINAPI StorageBaseImpl_AddRef(
 345             IStorage* iface)
 346 {
 347   StorageBaseImpl *This = (StorageBaseImpl *)iface;
 348   ULONG ref = InterlockedIncrement(&This->ref);
 349
 350   TRACE("(%p) AddRef to %d\n", This, ref);
 351
 352   return ref;
 353 }
 354
 355 /************************************************************************
 356  * Storage32BaseImpl_Release (IUnknown)
 357  *
 358  * This method implements the common Release for all IStorage32
 359  * implementations contained in this file.
 360  *
 361  * See Windows documentation for more details on IUnknown methods.
 362  */
 363 static ULONG WINAPI StorageBaseImpl_Release(
 364       IStorage* iface)
 365 {
 366   StorageBaseImpl *This = (StorageBaseImpl *)iface;
 367
 368   ULONG ref = InterlockedDecrement(&This->ref);
 369
 370   TRACE("(%p) ReleaseRef to %d\n", This, ref);
 371
 372   if (ref == 0)
 373   {
 374     /*
 375      * Since we are using a system of base-classes, we want to call the
 376      * destructor of the appropriate derived class. To do this, we are
 377      * using virtual functions to implement the destructor.
 378      */
 379     StorageBaseImpl_Destroy(This);
 380   }
 381
 382   return ref;
 383 }
 384
 385 /************************************************************************
 386  * Storage32BaseImpl_OpenStream (IStorage)
 387  *
 388  * This method will open the specified stream object from the current storage.
 389  *
 390  * See Windows documentation for more details on IStorage methods.
 391  */
 392 static HRESULT WINAPI StorageBaseImpl_OpenStream(
 393   IStorage*        iface,
 394   const OLECHAR*   pwcsName,  /* [string][in] */
 395   void*            reserved1, /* [unique][in] */
 396   DWORD            grfMode,   /* [in]  */
 397   DWORD            reserved2, /* [in]  */
 398   IStream**        ppstm)     /* [out] */
 399 {
 400   StorageBaseImpl *This = (StorageBaseImpl *)iface;
 401   StgStreamImpl*    newStream;
 402   DirEntry          currentEntry;
 403   DirRef            streamEntryRef;
 404   HRESULT           res = STG_E_UNKNOWN;
 405
 406   TRACE("(%p, %s, %p, %x, %d, %p)\n",
 407         iface, debugstr_w(pwcsName), reserved1, grfMode, reserved2, ppstm);
 408
 409   if ( (pwcsName==NULL) || (ppstm==0) )
 410   {
 411     res = E_INVALIDARG;
 412     goto end;
 413   }
 414
 415   *ppstm = NULL;
 416
 417   if ( FAILED( validateSTGM(grfMode) ) ||
 418        STGM_SHARE_MODE(grfMode) != STGM_SHARE_EXCLUSIVE)
 419   {
 420     res = STG_E_INVALIDFLAG;
 421     goto end;
 422   }
 423
 424   /*
 425    * As documented.
 426    */
 427   if ( (grfMode & STGM_DELETEONRELEASE) || (grfMode & STGM_TRANSACTED) )
 428   {
 429     res = STG_E_INVALIDFUNCTION;
 430     goto end;
 431   }
 432
 433   if (This->reverted)
 434   {
 435     res = STG_E_REVERTED;
 436     goto end;
 437   }
 438
 439   /*
 440    * Check that we're compatible with the parent's storage mode, but
 441    * only if we are not in transacted mode
 442    */
 443   if(!(This->openFlags & STGM_TRANSACTED)) {
 444     if ( STGM_ACCESS_MODE( grfMode ) > STGM_ACCESS_MODE( This->openFlags ) )
 445     {
 446       res = STG_E_INVALIDFLAG;
 447       goto end;
 448     }
 449   }
 450
 451   /*
 452    * Search for the element with the given name
 453    */
 454   streamEntryRef = findElement(
 455     This,
 456     This->storageDirEntry,
 457     pwcsName,
 458     &currentEntry);
 459
 460   /*
 461    * If it was found, construct the stream object and return a pointer to it.
 462    */
 463   if ( (streamEntryRef!=DIRENTRY_NULL) &&
 464        (currentEntry.stgType==STGTY_STREAM) )
 465   {
 466     if (StorageBaseImpl_IsStreamOpen(This, streamEntryRef))
 467     {
 468       /* A single stream cannot be opened a second time. */
 469       res = STG_E_ACCESSDENIED;
 470       goto end;
 471     }
 472
 473     newStream = StgStreamImpl_Construct(This, grfMode, streamEntryRef);
 474
 475     if (newStream!=0)
 476     {
 477       newStream->grfMode = grfMode;
 478       *ppstm = (IStream*)newStream;
 479
 480       IStream_AddRef(*ppstm);
 481
 482       res = S_OK;
 483       goto end;
 484     }
 485
 486     res = E_OUTOFMEMORY;
 487     goto end;
 488   }
 489
 490   res = STG_E_FILENOTFOUND;
 491
 492 end:
 493   if (res == S_OK)
 494     TRACE("<-- IStream %p\n", *ppstm);
 495   TRACE("<-- %08x\n", res);
 496   return res;
 497 }
 498
 499 /************************************************************************
 500  * Storage32BaseImpl_OpenStorage (IStorage)
 501  *
 502  * This method will open a new storage object from the current storage.
 503  *
 504  * See Windows documentation for more details on IStorage methods.
 505  */
 506 static HRESULT WINAPI StorageBaseImpl_OpenStorage(
 507   IStorage*        iface,
 508   const OLECHAR*   pwcsName,      /* [string][unique][in] */
 509   IStorage*        pstgPriority,  /* [unique][in] */
 510   DWORD            grfMode,       /* [in] */
 511   SNB              snbExclude,    /* [unique][in] */
 512   DWORD            reserved,      /* [in] */
 513   IStorage**       ppstg)         /* [out] */
 514 {
 515   StorageBaseImpl *This = (StorageBaseImpl *)iface;
 516   StorageInternalImpl*   newStorage;
 517   StorageBaseImpl*       newTransactedStorage;
 518   DirEntry               currentEntry;
 519   DirRef                 storageEntryRef;
 520   HRESULT                res = STG_E_UNKNOWN;
 521
 522   TRACE("(%p, %s, %p, %x, %p, %d, %p)\n",
 523         iface, debugstr_w(pwcsName), pstgPriority,
 524         grfMode, snbExclude, reserved, ppstg);
 525
 526   if ( (This==0) || (pwcsName==NULL) || (ppstg==0) )
 527   {
 528     res = E_INVALIDARG;
 529     goto end;
 530   }
 531
 532   if (This->openFlags & STGM_SIMPLE)
 533   {
 534     res = STG_E_INVALIDFUNCTION;
 535     goto end;
 536   }
 537
 538   /* as documented */
 539   if (snbExclude != NULL)
 540   {
 541     res = STG_E_INVALIDPARAMETER;
 542     goto end;
 543   }
 544
 545   if ( FAILED( validateSTGM(grfMode) ))
 546   {
 547     res = STG_E_INVALIDFLAG;
 548     goto end;
 549   }
 550
 551   /*
 552    * As documented.
 553    */
 554   if ( STGM_SHARE_MODE(grfMode) != STGM_SHARE_EXCLUSIVE ||
 555         (grfMode & STGM_DELETEONRELEASE) ||
 556         (grfMode & STGM_PRIORITY) )
 557   {
 558     res = STG_E_INVALIDFUNCTION;
 559     goto end;
 560   }
 561
 562   if (This->reverted)
 563     return STG_E_REVERTED;
 564
 565   /*
 566    * Check that we're compatible with the parent's storage mode,
 567    * but only if we are not transacted
 568    */
 569   if(!(This->openFlags & STGM_TRANSACTED)) {
 570     if ( STGM_ACCESS_MODE( grfMode ) > STGM_ACCESS_MODE( This->openFlags ) )
 571     {
 572       res = STG_E_ACCESSDENIED;
 573       goto end;
 574     }
 575   }
 576
 577   *ppstg = NULL;
 578
 579   storageEntryRef = findElement(
 580                          This,
 581                          This->storageDirEntry,
 582                          pwcsName,
 583                          &currentEntry);
 584
 585   if ( (storageEntryRef!=DIRENTRY_NULL) &&
 586        (currentEntry.stgType==STGTY_STORAGE) )
 587   {
 588     if (StorageBaseImpl_IsStorageOpen(This, storageEntryRef))
 589     {
 590       /* A single storage cannot be opened a second time. */
 591       res = STG_E_ACCESSDENIED;
 592       goto end;
 593     }
 594
 595     newStorage = StorageInternalImpl_Construct(
 596                    This,
 597                    grfMode,
 598                    storageEntryRef);
 599
 600     if (newStorage != 0)
 601     {
 602       if (grfMode & STGM_TRANSACTED)
 603       {
 604         res = Storage_ConstructTransacted(&newStorage->base, &newTransactedStorage);
 605
 606         if (FAILED(res))
 607         {
 608           HeapFree(GetProcessHeap(), 0, newStorage);
 609           goto end;
 610         }
 611
 612         *ppstg = (IStorage*)newTransactedStorage;
 613       }
 614       else
 615       {
 616         *ppstg = (IStorage*)newStorage;
 617       }
 618
 619       list_add_tail(&This->storageHead, &newStorage->ParentListEntry);
 620
 621       res = S_OK;
 622       goto end;
 623     }
 624
 625     res = STG_E_INSUFFICIENTMEMORY;
 626     goto end;
 627   }
 628
 629   res = STG_E_FILENOTFOUND;
 630
 631 end:
 632   TRACE("<-- %08x\n", res);
 633   return res;
 634 }
 635
 636 /************************************************************************
 637  * Storage32BaseImpl_EnumElements (IStorage)
 638  *
 639  * This method will create an enumerator object that can be used to
 640  * retrieve information about all the elements in the storage object.
 641  *
 642  * See Windows documentation for more details on IStorage methods.
 643  */
 644 static HRESULT WINAPI StorageBaseImpl_EnumElements(
 645   IStorage*       iface,
 646   DWORD           reserved1, /* [in] */
 647   void*           reserved2, /* [size_is][unique][in] */
 648   DWORD           reserved3, /* [in] */
 649   IEnumSTATSTG**  ppenum)    /* [out] */
 650 {
 651   StorageBaseImpl *This = (StorageBaseImpl *)iface;
 652   IEnumSTATSTGImpl* newEnum;
 653
 654   TRACE("(%p, %d, %p, %d, %p)\n",
 655         iface, reserved1, reserved2, reserved3, ppenum);
 656
 657   if ( (This==0) || (ppenum==0))
 658     return E_INVALIDARG;
 659
 660   if (This->reverted)
 661     return STG_E_REVERTED;
 662
 663   newEnum = IEnumSTATSTGImpl_Construct(
 664               This,
 665               This->storageDirEntry);
 666
 667   if (newEnum!=0)
 668   {
 669     *ppenum = (IEnumSTATSTG*)newEnum;
 670
 671     IEnumSTATSTG_AddRef(*ppenum);
 672
 673     return S_OK;
 674   }
 675
 676   return E_OUTOFMEMORY;
 677 }
 678
 679 /************************************************************************
 680  * Storage32BaseImpl_Stat (IStorage)
 681  *
 682  * This method will retrieve information about this storage object.
 683  *
 684  * See Windows documentation for more details on IStorage methods.
 685  */
 686 static HRESULT WINAPI StorageBaseImpl_Stat(
 687   IStorage*        iface,
 688   STATSTG*         pstatstg,     /* [out] */
 689   DWORD            grfStatFlag)  /* [in] */
 690 {
 691   StorageBaseImpl *This = (StorageBaseImpl *)iface;
 692   DirEntry       currentEntry;
 693   HRESULT        res = STG_E_UNKNOWN;
 694
 695   TRACE("(%p, %p, %x)\n",
 696         iface, pstatstg, grfStatFlag);
 697
 698   if ( (This==0) || (pstatstg==0))
 699   {
 700     res = E_INVALIDARG;
 701     goto end;
 702   }
 703
 704   if (This->reverted)
 705   {
 706     res = STG_E_REVERTED;
 707     goto end;
 708   }
 709
 710   res = StorageBaseImpl_ReadDirEntry(
 711                     This,
 712                     This->storageDirEntry,
 713                     &currentEntry);
 714
 715   if (SUCCEEDED(res))
 716   {
 717     StorageUtl_CopyDirEntryToSTATSTG(
 718       This,
 719       pstatstg,
 720       &currentEntry,
 721       grfStatFlag);
 722
 723     pstatstg->grfMode = This->openFlags;
 724     pstatstg->grfStateBits = This->stateBits;
 725   }
 726
 727 end:
 728   if (res == S_OK)
 729   {
 730     TRACE("<-- STATSTG: pwcsName: %s, type: %d, cbSize.Low/High: %d/%d, grfMode: %08x, grfLocksSupported: %d, grfStateBits: %08x\n", debugstr_w(pstatstg->pwcsName), pstatstg->type, pstatstg->cbSize.u.LowPart, pstatstg->cbSize.u.HighPart, pstatstg->grfMode, pstatstg->grfLocksSupported, pstatstg->grfStateBits);
 731   }
 732   TRACE("<-- %08x\n", res);
 733   return res;
 734 }
 735
 736 /************************************************************************
 737  * Storage32BaseImpl_RenameElement (IStorage)
 738  *
 739  * This method will rename the specified element.
 740  *
 741  * See Windows documentation for more details on IStorage methods.
 742  */
 743 static HRESULT WINAPI StorageBaseImpl_RenameElement(
 744             IStorage*        iface,
 745             const OLECHAR*   pwcsOldName,  /* [in] */
 746             const OLECHAR*   pwcsNewName)  /* [in] */
 747 {
 748   StorageBaseImpl *This = (StorageBaseImpl *)iface;
 749   DirEntry          currentEntry;
 750   DirRef            currentEntryRef;
 751
 752   TRACE("(%p, %s, %s)\n",
 753         iface, debugstr_w(pwcsOldName), debugstr_w(pwcsNewName));
 754
 755   if (This->reverted)
 756     return STG_E_REVERTED;
 757
 758   currentEntryRef = findElement(This,
 759                                    This->storageDirEntry,
 760                                    pwcsNewName,
 761                                    &currentEntry);
 762
 763   if (currentEntryRef != DIRENTRY_NULL)
 764   {
 765     /*
 766      * There is already an element with the new name
 767      */
 768     return STG_E_FILEALREADYEXISTS;
 769   }
 770
 771   /*
 772    * Search for the old element name
 773    */
 774   currentEntryRef = findElement(This,
 775                                    This->storageDirEntry,
 776                                    pwcsOldName,
 777                                    &currentEntry);
 778
 779   if (currentEntryRef != DIRENTRY_NULL)
 780   {
 781     if (StorageBaseImpl_IsStreamOpen(This, currentEntryRef) ||
 782         StorageBaseImpl_IsStorageOpen(This, currentEntryRef))
 783     {
 784       WARN("Element is already open; cannot rename.\n");
 785       return STG_E_ACCESSDENIED;
 786     }
 787
 788     /* Remove the element from its current position in the tree */
 789     removeFromTree(This, This->storageDirEntry,
 790         currentEntryRef);
 791
 792     /* Change the name of the element */
 793     strcpyW(currentEntry.name, pwcsNewName);
 794
 795     /* Delete any sibling links */
 796     currentEntry.leftChild = DIRENTRY_NULL;
 797     currentEntry.rightChild = DIRENTRY_NULL;
 798
 799     StorageBaseImpl_WriteDirEntry(This, currentEntryRef,
 800         &currentEntry);
 801
 802     /* Insert the element in a new position in the tree */
 803     insertIntoTree(This, This->storageDirEntry,
 804         currentEntryRef);
 805   }
 806   else
 807   {
 808     /*
 809      * There is no element with the old name
 810      */
 811     return STG_E_FILENOTFOUND;
 812   }
 813
 814   return S_OK;
 815 }
 816
 817 /************************************************************************
 818  * Storage32BaseImpl_CreateStream (IStorage)
 819  *
 820  * This method will create a stream object within this storage
 821  *
 822  * See Windows documentation for more details on IStorage methods.
 823  */
 824 static HRESULT WINAPI StorageBaseImpl_CreateStream(
 825             IStorage*        iface,
 826             const OLECHAR*   pwcsName,  /* [string][in] */
 827             DWORD            grfMode,   /* [in] */
 828             DWORD            reserved1, /* [in] */
 829             DWORD            reserved2, /* [in] */
 830             IStream**        ppstm)     /* [out] */
 831 {
 832   StorageBaseImpl *This = (StorageBaseImpl *)iface;
 833   StgStreamImpl*    newStream;
 834   DirEntry          currentEntry, newStreamEntry;
 835   DirRef            currentEntryRef, newStreamEntryRef;
 836   HRESULT hr;
 837
 838   TRACE("(%p, %s, %x, %d, %d, %p)\n",
 839         iface, debugstr_w(pwcsName), grfMode,
 840         reserved1, reserved2, ppstm);
 841
 842   if (ppstm == 0)
 843     return STG_E_INVALIDPOINTER;
 844
 845   if (pwcsName == 0)
 846     return STG_E_INVALIDNAME;
 847
 848   if (reserved1 || reserved2)
 849     return STG_E_INVALIDPARAMETER;
 850
 851   if ( FAILED( validateSTGM(grfMode) ))
 852     return STG_E_INVALIDFLAG;
 853
 854   if (STGM_SHARE_MODE(grfMode) != STGM_SHARE_EXCLUSIVE)
 855     return STG_E_INVALIDFLAG;
 856
 857   if (This->reverted)
 858     return STG_E_REVERTED;
 859
 860   /*
 861    * As documented.
 862    */
 863   if ((grfMode & STGM_DELETEONRELEASE) ||
 864       (grfMode & STGM_TRANSACTED))
 865     return STG_E_INVALIDFUNCTION;
 866
 867   /*
 868    * Don't worry about permissions in transacted mode, as we can always write
 869    * changes; we just can't always commit them.
 870    */
 871   if(!(This->openFlags & STGM_TRANSACTED)) {
 872     /* Can't create a stream on read-only storage */
 873     if ( STGM_ACCESS_MODE( This->openFlags ) == STGM_READ )
 874       return STG_E_ACCESSDENIED;
 875
 876     /* Can't create a stream with greater access than the parent. */
 877     if ( STGM_ACCESS_MODE( grfMode ) > STGM_ACCESS_MODE( This->openFlags ) )
 878       return STG_E_ACCESSDENIED;
 879   }
 880
 881   if(This->openFlags & STGM_SIMPLE)
 882     if(grfMode & STGM_CREATE) return STG_E_INVALIDFLAG;
 883
 884   *ppstm = 0;
 885
 886   currentEntryRef = findElement(This,
 887                                    This->storageDirEntry,
 888                                    pwcsName,
 889                                    &currentEntry);
 890
 891   if (currentEntryRef != DIRENTRY_NULL)
 892   {
 893     /*
 894      * An element with this name already exists
 895      */
 896     if (STGM_CREATE_MODE(grfMode) == STGM_CREATE)
 897     {
 898       IStorage_DestroyElement(iface, pwcsName);
 899     }
 900     else
 901       return STG_E_FILEALREADYEXISTS;
 902   }
 903
 904   /*
 905    * memset the empty entry
 906    */
 907   memset(&newStreamEntry, 0, sizeof(DirEntry));
 908
 909   newStreamEntry.sizeOfNameString =
 910       ( lstrlenW(pwcsName)+1 ) * sizeof(WCHAR);
 911
 912   if (newStreamEntry.sizeOfNameString > DIRENTRY_NAME_BUFFER_LEN)
 913     return STG_E_INVALIDNAME;
 914
 915   strcpyW(newStreamEntry.name, pwcsName);
 916
 917   newStreamEntry.stgType       = STGTY_STREAM;
 918   newStreamEntry.startingBlock = BLOCK_END_OF_CHAIN;
 919   newStreamEntry.size.u.LowPart  = 0;
 920   newStreamEntry.size.u.HighPart = 0;
 921
 922   newStreamEntry.leftChild        = DIRENTRY_NULL;
 923   newStreamEntry.rightChild       = DIRENTRY_NULL;
 924   newStreamEntry.dirRootEntry     = DIRENTRY_NULL;
 925
 926   /* call CoFileTime to get the current time
 927   newStreamEntry.ctime
 928   newStreamEntry.mtime
 929   */
 930
 931   /*  newStreamEntry.clsid */
 932
 933   /*
 934    * Create an entry with the new data
 935    */
 936   hr = StorageBaseImpl_CreateDirEntry(This, &newStreamEntry, &newStreamEntryRef);
 937   if (FAILED(hr))
 938     return hr;
 939
 940   /*
 941    * Insert the new entry in the parent storage's tree.
 942    */
 943   hr = insertIntoTree(
 944     This,
 945     This->storageDirEntry,
 946     newStreamEntryRef);
 947   if (FAILED(hr))
 948   {
 949     StorageBaseImpl_DestroyDirEntry(This, newStreamEntryRef);
 950     return hr;
 951   }
 952
 953   /*
 954    * Open the stream to return it.
 955    */
 956   newStream = StgStreamImpl_Construct(This, grfMode, newStreamEntryRef);
 957
 958   if (newStream != 0)
 959   {
 960     *ppstm = (IStream*)newStream;
 961
 962     IStream_AddRef(*ppstm);
 963   }
 964   else
 965   {
 966     return STG_E_INSUFFICIENTMEMORY;
 967   }
 968
 969   return S_OK;
 970 }
 971
 972 /************************************************************************
 973  * Storage32BaseImpl_SetClass (IStorage)
 974  *
 975  * This method will write the specified CLSID in the directory entry of this
 976  * storage.
 977  *
 978  * See Windows documentation for more details on IStorage methods.
 979  */
 980 static HRESULT WINAPI StorageBaseImpl_SetClass(
 981   IStorage*        iface,
 982   REFCLSID         clsid) /* [in] */
 983 {
 984   StorageBaseImpl *This = (StorageBaseImpl *)iface;
 985   HRESULT hRes;
 986   DirEntry currentEntry;
 987
 988   TRACE("(%p, %p)\n", iface, clsid);
 989
 990   if (This->reverted)
 991     return STG_E_REVERTED;
 992
 993   hRes = StorageBaseImpl_ReadDirEntry(This,
 994                                       This->storageDirEntry,
 995                                       &currentEntry);
 996   if (SUCCEEDED(hRes))
 997   {
 998     currentEntry.clsid = *clsid;
 999
1000     hRes = StorageBaseImpl_WriteDirEntry(This,
1001                                          This->storageDirEntry,
1002                                          &currentEntry);
1003   }
1004
1005   return hRes;
1006 }
1007
1008 /************************************************************************
1009 ** Storage32Impl implementation
1010 */
1011
1012 /************************************************************************
1013  * Storage32BaseImpl_CreateStorage (IStorage)
1014  *
1015  * This method will create the storage object within the provided storage.
1016  *
1017  * See Windows documentation for more details on IStorage methods.
1018  */
1019 static HRESULT WINAPI StorageBaseImpl_CreateStorage(
1020   IStorage*      iface,
1021   const OLECHAR  *pwcsName, /* [string][in] */
1022   DWORD            grfMode,   /* [in] */
1023   DWORD            reserved1, /* [in] */
1024   DWORD            reserved2, /* [in] */
1025   IStorage       **ppstg)   /* [out] */
1026 {
1027   StorageBaseImpl* const This=(StorageBaseImpl*)iface;
1028
1029   DirEntry         currentEntry;
1030   DirEntry         newEntry;
1031   DirRef           currentEntryRef;
1032   DirRef           newEntryRef;
1033   HRESULT          hr;
1034
1035   TRACE("(%p, %s, %x, %d, %d, %p)\n",
1036         iface, debugstr_w(pwcsName), grfMode,
1037         reserved1, reserved2, ppstg);
1038
1039   if (ppstg == 0)
1040     return STG_E_INVALIDPOINTER;
1041
1042   if (This->openFlags & STGM_SIMPLE)
1043   {
1044     return STG_E_INVALIDFUNCTION;
1045   }
1046
1047   if (pwcsName == 0)
1048     return STG_E_INVALIDNAME;
1049
1050   *ppstg = NULL;
1051
1052   if ( FAILED( validateSTGM(grfMode) ) ||
1053        (grfMode & STGM_DELETEONRELEASE) )
1054   {
1055     WARN("bad grfMode: 0x%x\n", grfMode);
1056     return STG_E_INVALIDFLAG;
1057   }
1058
1059   if (This->reverted)
1060     return STG_E_REVERTED;
1061
1062   /*
1063    * Check that we're compatible with the parent's storage mode
1064    */
1065   if ( !(This->openFlags & STGM_TRANSACTED) &&
1066        STGM_ACCESS_MODE( grfMode ) > STGM_ACCESS_MODE( This->openFlags ) )
1067   {
1068     WARN("access denied\n");
1069     return STG_E_ACCESSDENIED;
1070   }
1071
1072   currentEntryRef = findElement(This,
1073                                    This->storageDirEntry,
1074                                    pwcsName,
1075                                    &currentEntry);
1076
1077   if (currentEntryRef != DIRENTRY_NULL)
1078   {
1079     /*
1080      * An element with this name already exists
1081      */
1082     if (STGM_CREATE_MODE(grfMode) == STGM_CREATE &&
1083         ((This->openFlags & STGM_TRANSACTED) ||
1084          STGM_ACCESS_MODE(This->openFlags) != STGM_READ))
1085     {
1086       hr = IStorage_DestroyElement(iface, pwcsName);
1087       if (FAILED(hr))
1088         return hr;
1089     }
1090     else
1091     {
1092       WARN("file already exists\n");
1093       return STG_E_FILEALREADYEXISTS;
1094     }
1095   }
1096   else if (!(This->openFlags & STGM_TRANSACTED) &&
1097            STGM_ACCESS_MODE(This->openFlags) == STGM_READ)
1098   {
1099     WARN("read-only storage\n");
1100     return STG_E_ACCESSDENIED;
1101   }
1102
1103   memset(&newEntry, 0, sizeof(DirEntry));
1104
1105   newEntry.sizeOfNameString = (lstrlenW(pwcsName)+1)*sizeof(WCHAR);
1106
1107   if (newEntry.sizeOfNameString > DIRENTRY_NAME_BUFFER_LEN)
1108   {
1109     FIXME("name too long\n");
1110     return STG_E_INVALIDNAME;
1111   }
1112
1113   strcpyW(newEntry.name, pwcsName);
1114
1115   newEntry.stgType       = STGTY_STORAGE;
1116   newEntry.startingBlock = BLOCK_END_OF_CHAIN;
1117   newEntry.size.u.LowPart  = 0;
1118   newEntry.size.u.HighPart = 0;
1119
1120   newEntry.leftChild        = DIRENTRY_NULL;
1121   newEntry.rightChild       = DIRENTRY_NULL;
1122   newEntry.dirRootEntry     = DIRENTRY_NULL;
1123
1124   /* call CoFileTime to get the current time
1125   newEntry.ctime
1126   newEntry.mtime
1127   */
1128
1129   /*  newEntry.clsid */
1130
1131   /*
1132    * Create a new directory entry for the storage
1133    */
1134   hr = StorageBaseImpl_CreateDirEntry(This, &newEntry, &newEntryRef);
1135   if (FAILED(hr))
1136     return hr;
1137
1138   /*
1139    * Insert the new directory entry into the parent storage's tree
1140    */
1141   hr = insertIntoTree(
1142     This,
1143     This->storageDirEntry,
1144     newEntryRef);
1145   if (FAILED(hr))
1146   {
1147     StorageBaseImpl_DestroyDirEntry(This, newEntryRef);
1148     return hr;
1149   }
1150
1151   /*
1152    * Open it to get a pointer to return.
1153    */
1154   hr = IStorage_OpenStorage(iface, pwcsName, 0, grfMode, 0, 0, ppstg);
1155
1156   if( (hr != S_OK) || (*ppstg == NULL))
1157   {
1158     return hr;
1159   }
1160
1161
1162   return S_OK;
1163 }
1164
1165
1166 /***************************************************************************
1167  *
1168  * Internal Method
1169  *
1170  * Reserve a directory entry in the file and initialize it.
1171  */
1172 static HRESULT StorageImpl_CreateDirEntry(
1173   StorageBaseImpl *base,
1174   const DirEntry *newData,
1175   DirRef *index)
1176 {
1177   StorageImpl *storage = (StorageImpl*)base;
1178   ULONG       currentEntryIndex    = 0;
1179   ULONG       newEntryIndex        = DIRENTRY_NULL;
1180   HRESULT hr = S_OK;
1181   BYTE currentData[RAW_DIRENTRY_SIZE];
1182   WORD sizeOfNameString;
1183
1184   do
1185   {
1186     hr = StorageImpl_ReadRawDirEntry(storage,
1187                                      currentEntryIndex,
1188                                      currentData);
1189
1190     if (SUCCEEDED(hr))
1191     {
1192       StorageUtl_ReadWord(
1193         currentData,
1194         OFFSET_PS_NAMELENGTH,
1195         &sizeOfNameString);
1196
1197       if (sizeOfNameString == 0)
1198       {
1199         /*
1200          * The entry exists and is available, we found it.
1201          */
1202         newEntryIndex = currentEntryIndex;
1203       }
1204     }
1205     else
1206     {
1207       /*
1208        * We exhausted the directory entries, we will create more space below
1209        */
1210       newEntryIndex = currentEntryIndex;
1211     }
1212     currentEntryIndex++;
1213
1214   } while (newEntryIndex == DIRENTRY_NULL);
1215
1216   /*
1217    * grow the directory stream
1218    */
1219   if (FAILED(hr))
1220   {
1221     BYTE           emptyData[RAW_DIRENTRY_SIZE];
1222     ULARGE_INTEGER newSize;
1223     ULONG          entryIndex;
1224     ULONG          lastEntry     = 0;
1225     ULONG          blockCount    = 0;
1226
1227     /*
1228      * obtain the new count of blocks in the directory stream
1229      */
1230     blockCount = BlockChainStream_GetCount(
1231                    storage->rootBlockChain)+1;
1232
1233     /*
1234      * initialize the size used by the directory stream
1235      */
1236     newSize.u.HighPart = 0;
1237     newSize.u.LowPart  = storage->bigBlockSize * blockCount;
1238
1239     /*
1240      * add a block to the directory stream
1241      */
1242     BlockChainStream_SetSize(storage->rootBlockChain, newSize);
1243
1244     /*
1245      * memset the empty entry in order to initialize the unused newly
1246      * created entries
1247      */
1248     memset(&emptyData, 0, RAW_DIRENTRY_SIZE);
1249
1250     /*
1251      * initialize them
1252      */
1253     lastEntry = storage->bigBlockSize / RAW_DIRENTRY_SIZE * blockCount;
1254
1255     for(
1256       entryIndex = newEntryIndex + 1;
1257       entryIndex < lastEntry;
1258       entryIndex++)
1259     {
1260       StorageImpl_WriteRawDirEntry(
1261         storage,
1262         entryIndex,
1263         emptyData);
1264     }
1265   }
1266
1267   UpdateRawDirEntry(currentData, newData);
1268
1269   hr = StorageImpl_WriteRawDirEntry(storage, newEntryIndex, currentData);
1270
1271   if (SUCCEEDED(hr))
1272     *index = newEntryIndex;
1273
1274   return hr;
1275 }
1276
1277 /***************************************************************************
1278  *
1279  * Internal Method
1280  *
1281  * Mark a directory entry in the file as free.
1282  */
1283 static HRESULT StorageImpl_DestroyDirEntry(
1284   StorageBaseImpl *base,
1285   DirRef index)
1286 {
1287   HRESULT hr;
1288   BYTE emptyData[RAW_DIRENTRY_SIZE];
1289   StorageImpl *storage = (StorageImpl*)base;
1290
1291   memset(&emptyData, 0, RAW_DIRENTRY_SIZE);
1292
1293   hr = StorageImpl_WriteRawDirEntry(storage, index, emptyData);
1294
1295   return hr;
1296 }
1297
1298
1299 /***************************************************************************
1300  *
1301  * Internal Method
1302  *
1303  * Destroy an entry, its attached data, and all entries reachable from it.
1304  */
1305 static HRESULT DestroyReachableEntries(
1306   StorageBaseImpl *base,
1307   DirRef index)
1308 {
1309   HRESULT hr = S_OK;
1310   DirEntry data;
1311   ULARGE_INTEGER zero;
1312
1313   zero.QuadPart = 0;
1314
1315   if (index != DIRENTRY_NULL)
1316   {
1317     hr = StorageBaseImpl_ReadDirEntry(base, index, &data);
1318
1319     if (SUCCEEDED(hr))
1320       hr = DestroyReachableEntries(base, data.dirRootEntry);
1321
1322     if (SUCCEEDED(hr))
1323       hr = DestroyReachableEntries(base, data.leftChild);
1324
1325     if (SUCCEEDED(hr))
1326       hr = DestroyReachableEntries(base, data.rightChild);
1327
1328     if (SUCCEEDED(hr))
1329       hr = StorageBaseImpl_StreamSetSize(base, index, zero);
1330
1331     if (SUCCEEDED(hr))
1332       hr = StorageBaseImpl_DestroyDirEntry(base, index);
1333   }
1334
1335   return hr;
1336 }
1337
1338
1339 /****************************************************************************
1340  *
1341  * Internal Method
1342  *
1343  * Case insensitive comparison of DirEntry.name by first considering
1344  * their size.
1345  *
1346  * Returns <0 when name1 < name2
1347  *         >0 when name1 > name2
1348  *          0 when name1 == name2
1349  */
1350 static LONG entryNameCmp(
1351     const OLECHAR *name1,
1352     const OLECHAR *name2)
1353 {
1354   LONG diff      = lstrlenW(name1) - lstrlenW(name2);
1355
1356   while (diff == 0 && *name1 != 0)
1357   {
1358     /*
1359      * We compare the string themselves only when they are of the same length
1360      */
1361     diff = toupperW(*name1++) - toupperW(*name2++);
1362   }
1363
1364   return diff;
1365 }
1366
1367 /****************************************************************************
1368  *
1369  * Internal Method
1370  *
1371  * Add a directory entry to a storage
1372  */
1373 static HRESULT insertIntoTree(
1374   StorageBaseImpl *This,
1375   DirRef        parentStorageIndex,
1376   DirRef        newEntryIndex)
1377 {
1378   DirEntry currentEntry;
1379   DirEntry newEntry;
1380
1381   /*
1382    * Read the inserted entry
1383    */
1384   StorageBaseImpl_ReadDirEntry(This,
1385                                newEntryIndex,
1386                                &newEntry);
1387
1388   /*
1389    * Read the storage entry
1390    */
1391   StorageBaseImpl_ReadDirEntry(This,
1392                                parentStorageIndex,
1393                                &currentEntry);
1394
1395   if (currentEntry.dirRootEntry != DIRENTRY_NULL)
1396   {
1397     /*
1398      * The root storage contains some element, therefore, start the research
1399      * for the appropriate location.
1400      */
1401     BOOL found = 0;
1402     DirRef current, next, previous, currentEntryId;
1403
1404     /*
1405      * Keep a reference to the root of the storage's element tree
1406      */
1407     currentEntryId = currentEntry.dirRootEntry;
1408
1409     /*
1410      * Read
1411      */
1412     StorageBaseImpl_ReadDirEntry(This,
1413                                  currentEntry.dirRootEntry,
1414                                  &currentEntry);
1415
1416     previous = currentEntry.leftChild;
1417     next     = currentEntry.rightChild;
1418     current  = currentEntryId;
1419
1420     while (found == 0)
1421     {
1422       LONG diff = entryNameCmp( newEntry.name, currentEntry.name);
1423
1424       if (diff < 0)
1425       {
1426         if (previous != DIRENTRY_NULL)
1427         {
1428           StorageBaseImpl_ReadDirEntry(This,
1429                                        previous,
1430                                        &currentEntry);
1431           current = previous;
1432         }
1433         else
1434         {
1435           currentEntry.leftChild = newEntryIndex;
1436           StorageBaseImpl_WriteDirEntry(This,
1437                                         current,
1438                                         &currentEntry);
1439           found = 1;
1440         }
1441       }
1442       else if (diff > 0)
1443       {
1444         if (next != DIRENTRY_NULL)
1445         {
1446           StorageBaseImpl_ReadDirEntry(This,
1447                                        next,
1448                                        &currentEntry);
1449           current = next;
1450         }
1451         else
1452         {
1453           currentEntry.rightChild = newEntryIndex;
1454           StorageBaseImpl_WriteDirEntry(This,
1455                                         current,
1456                                         &currentEntry);
1457           found = 1;
1458         }
1459       }
1460       else
1461       {
1462         /*
1463          * Trying to insert an item with the same name in the
1464          * subtree structure.
1465          */
1466         return STG_E_FILEALREADYEXISTS;
1467       }
1468
1469       previous = currentEntry.leftChild;
1470       next     = currentEntry.rightChild;
1471     }
1472   }
1473   else
1474   {
1475     /*
1476      * The storage is empty, make the new entry the root of its element tree
1477      */
1478     currentEntry.dirRootEntry = newEntryIndex;
1479     StorageBaseImpl_WriteDirEntry(This,
1480                                   parentStorageIndex,
1481                                   &currentEntry);
1482   }
1483
1484   return S_OK;
1485 }
1486
1487 /****************************************************************************
1488  *
1489  * Internal Method
1490  *
1491  * Find and read the element of a storage with the given name.
1492  */
1493 static DirRef findElement(StorageBaseImpl *storage, DirRef storageEntry,
1494     const OLECHAR *name, DirEntry *data)
1495 {
1496   DirRef currentEntry;
1497
1498   /* Read the storage entry to find the root of the tree. */
1499   StorageBaseImpl_ReadDirEntry(storage, storageEntry, data);
1500
1501   currentEntry = data->dirRootEntry;
1502
1503   while (currentEntry != DIRENTRY_NULL)
1504   {
1505     LONG cmp;
1506
1507     StorageBaseImpl_ReadDirEntry(storage, currentEntry, data);
1508
1509     cmp = entryNameCmp(name, data->name);
1510
1511     if (cmp == 0)
1512       /* found it */
1513       break;
1514
1515     else if (cmp < 0)
1516       currentEntry = data->leftChild;
1517
1518     else if (cmp > 0)
1519       currentEntry = data->rightChild;
1520   }
1521
1522   return currentEntry;
1523 }
1524
1525 /****************************************************************************
1526  *
1527  * Internal Method
1528  *
1529  * Find and read the binary tree parent of the element with the given name.
1530  *
1531  * If there is no such element, find a place where it could be inserted and
1532  * return STG_E_FILENOTFOUND.
1533  */
1534 static HRESULT findTreeParent(StorageBaseImpl *storage, DirRef storageEntry,
1535     const OLECHAR *childName, DirEntry *parentData, DirRef *parentEntry,
1536     ULONG *relation)
1537 {
1538   DirRef childEntry;
1539   DirEntry childData;
1540
1541   /* Read the storage entry to find the root of the tree. */
1542   StorageBaseImpl_ReadDirEntry(storage, storageEntry, parentData);
1543
1544   *parentEntry = storageEntry;
1545   *relation = DIRENTRY_RELATION_DIR;
1546
1547   childEntry = parentData->dirRootEntry;
1548
1549   while (childEntry != DIRENTRY_NULL)
1550   {
1551     LONG cmp;
1552
1553     StorageBaseImpl_ReadDirEntry(storage, childEntry, &childData);
1554
1555     cmp = entryNameCmp(childName, childData.name);
1556
1557     if (cmp == 0)
1558       /* found it */
1559       break;
1560
1561     else if (cmp < 0)
1562     {
1563       *parentData = childData;
1564       *parentEntry = childEntry;
1565       *relation = DIRENTRY_RELATION_PREVIOUS;
1566
1567       childEntry = parentData->leftChild;
1568     }
1569
1570     else if (cmp > 0)
1571     {
1572       *parentData = childData;
1573       *parentEntry = childEntry;
1574       *relation = DIRENTRY_RELATION_NEXT;
1575
1576       childEntry = parentData->rightChild;
1577     }
1578   }
1579
1580   if (childEntry == DIRENTRY_NULL)
1581     return STG_E_FILENOTFOUND;
1582   else
1583     return S_OK;
1584 }
1585
1586
1587 /*************************************************************************
1588  * CopyTo (IStorage)
1589  */
1590 static HRESULT WINAPI StorageBaseImpl_CopyTo(
1591   IStorage*   iface,
1592   DWORD       ciidExclude,  /* [in] */
1593   const IID*  rgiidExclude, /* [size_is][unique][in] */
1594   SNB         snbExclude,   /* [unique][in] */
1595   IStorage*   pstgDest)     /* [unique][in] */
1596 {
1597   StorageBaseImpl* const This=(StorageBaseImpl*)iface;
1598
1599   IEnumSTATSTG *elements     = 0;
1600   STATSTG      curElement, strStat;
1601   HRESULT      hr;
1602   IStorage     *pstgTmp, *pstgChild;
1603   IStream      *pstrTmp, *pstrChild;
1604   DirRef       srcEntryRef;
1605   DirEntry     srcEntry;
1606   BOOL         skip = FALSE, skip_storage = FALSE, skip_stream = FALSE;
1607   int          i;
1608
1609   TRACE("(%p, %d, %p, %p, %p)\n",
1610         iface, ciidExclude, rgiidExclude,
1611         snbExclude, pstgDest);
1612
1613   if ( pstgDest == 0 )
1614     return STG_E_INVALIDPOINTER;
1615
1616   /*
1617    * Enumerate the elements
1618    */
1619   hr = IStorage_EnumElements( iface, 0, 0, 0, &elements );
1620
1621   if ( hr != S_OK )
1622     return hr;
1623
1624   /*
1625    * set the class ID
1626    */
1627   IStorage_Stat( iface, &curElement, STATFLAG_NONAME);
1628   IStorage_SetClass( pstgDest, &curElement.clsid );
1629
1630   for(i = 0; i < ciidExclude; ++i)
1631   {
1632     if(IsEqualGUID(&IID_IStorage, &rgiidExclude[i]))
1633         skip_storage = TRUE;
1634     else if(IsEqualGUID(&IID_IStream, &rgiidExclude[i]))
1635         skip_stream = TRUE;
1636     else
1637         WARN("Unknown excluded GUID: %s\n", debugstr_guid(&rgiidExclude[i]));
1638   }
1639
1640   do
1641   {
1642     /*
1643      * Obtain the next element
1644      */
1645     hr = IEnumSTATSTG_Next( elements, 1, &curElement, NULL );
1646
1647     if ( hr == S_FALSE )
1648     {
1649       hr = S_OK;   /* done, every element has been copied */
1650       break;
1651     }
1652
1653     if ( snbExclude )
1654     {
1655       WCHAR **snb = snbExclude;
1656       skip = FALSE;
1657       while ( *snb != NULL && !skip )
1658       {
1659         if ( lstrcmpW(curElement.pwcsName, *snb) == 0 )
1660           skip = TRUE;
1661         ++snb;
1662       }
1663     }
1664
1665     if ( skip )
1666       goto cleanup;
1667
1668     if (curElement.type == STGTY_STORAGE)
1669     {
1670       if(skip_storage)
1671         goto cleanup;
1672
1673       /*
1674        * open child source storage
1675        */
1676       hr = IStorage_OpenStorage( iface, curElement.pwcsName, NULL,
1677                                  STGM_READ|STGM_SHARE_EXCLUSIVE,
1678                                  NULL, 0, &pstgChild );
1679
1680       if (hr != S_OK)
1681         goto cleanup;
1682
1683       /*
1684        * create a new storage in destination storage
1685        */
1686       hr = IStorage_CreateStorage( pstgDest, curElement.pwcsName,
1687                                    STGM_FAILIFTHERE|STGM_WRITE|STGM_SHARE_EXCLUSIVE,
1688                                    0, 0,
1689                                    &pstgTmp );
1690       /*
1691        * if it already exist, don't create a new one use this one
1692        */
1693       if (hr == STG_E_FILEALREADYEXISTS)
1694       {
1695         hr = IStorage_OpenStorage( pstgDest, curElement.pwcsName, NULL,
1696                                    STGM_WRITE|STGM_SHARE_EXCLUSIVE,
1697                                    NULL, 0, &pstgTmp );
1698       }
1699
1700       if (hr == S_OK)
1701       {
1702         /*
1703          * do the copy recursively
1704          */
1705         hr = IStorage_CopyTo( pstgChild, ciidExclude, rgiidExclude,
1706                                  NULL, pstgTmp );
1707
1708         IStorage_Release( pstgTmp );
1709       }
1710
1711       IStorage_Release( pstgChild );
1712     }
1713     else if (curElement.type == STGTY_STREAM)
1714     {
1715       if(skip_stream)
1716         goto cleanup;
1717
1718       /*
1719        * create a new stream in destination storage. If the stream already
1720        * exist, it will be deleted and a new one will be created.
1721        */
1722       hr = IStorage_CreateStream( pstgDest, curElement.pwcsName,
1723                                   STGM_CREATE|STGM_WRITE|STGM_SHARE_EXCLUSIVE,
1724                                   0, 0, &pstrTmp );
1725
1726       if (hr != S_OK)
1727         goto cleanup;
1728
1729       /*
1730        * open child stream storage. This operation must succeed even if the
1731        * stream is already open, so we use internal functions to do it.
1732        */
1733       srcEntryRef = findElement( This, This->storageDirEntry, curElement.pwcsName,
1734         &srcEntry);
1735       if (!srcEntryRef)
1736       {
1737         ERR("source stream not found\n");
1738         hr = STG_E_DOCFILECORRUPT;
1739       }
1740
1741       if (hr == S_OK)
1742       {
1743         pstrChild = (IStream*)StgStreamImpl_Construct(This, STGM_READ|STGM_SHARE_EXCLUSIVE, srcEntryRef);
1744         if (pstrChild)
1745           IStream_AddRef(pstrChild);
1746         else
1747           hr = E_OUTOFMEMORY;
1748       }
1749
1750       if (hr == S_OK)
1751       {
1752         /*
1753          * Get the size of the source stream
1754          */
1755         IStream_Stat( pstrChild, &strStat, STATFLAG_NONAME );
1756
1757         /*
1758          * Set the size of the destination stream.
1759          */
1760         IStream_SetSize(pstrTmp, strStat.cbSize);
1761
1762         /*
1763          * do the copy
1764          */
1765         hr = IStream_CopyTo( pstrChild, pstrTmp, strStat.cbSize,
1766                              NULL, NULL );
1767
1768         IStream_Release( pstrChild );
1769       }
1770
1771       IStream_Release( pstrTmp );
1772     }
1773     else
1774     {
1775       WARN("unknown element type: %d\n", curElement.type);
1776     }
1777
1778 cleanup:
1779     CoTaskMemFree(curElement.pwcsName);
1780   } while (hr == S_OK);
1781
1782   /*
1783    * Clean-up
1784    */
1785   IEnumSTATSTG_Release(elements);
1786
1787   return hr;
1788 }
1789
1790 /*************************************************************************
1791  * MoveElementTo (IStorage)
1792  */
1793 static HRESULT WINAPI StorageBaseImpl_MoveElementTo(
1794   IStorage*     iface,
1795   const OLECHAR *pwcsName,   /* [string][in] */
1796   IStorage      *pstgDest,   /* [unique][in] */
1797   const OLECHAR *pwcsNewName,/* [string][in] */
1798   DWORD           grfFlags)    /* [in] */
1799 {
1800   FIXME("(%p %s %p %s %u): stub\n", iface,
1801          debugstr_w(pwcsName), pstgDest,
1802          debugstr_w(pwcsNewName), grfFlags);
1803   return E_NOTIMPL;
1804 }
1805
1806 /*************************************************************************
1807  * Commit (IStorage)
1808  *
1809  * Ensures that any changes made to a storage object open in transacted mode
1810  * are reflected in the parent storage
1811  *
1812  * NOTES
1813  *  Wine doesn't implement transacted mode, which seems to be a basic
1814  *  optimization, so we can ignore this stub for now.
1815  */
1816 static HRESULT WINAPI StorageImpl_Commit(
1817   IStorage*   iface,
1818   DWORD         grfCommitFlags)/* [in] */
1819 {
1820   FIXME("(%p %d): stub\n", iface, grfCommitFlags);
1821   return S_OK;
1822 }
1823
1824 /*************************************************************************
1825  * Revert (IStorage)
1826  *
1827  * Discard all changes that have been made since the last commit operation
1828  */
1829 static HRESULT WINAPI StorageImpl_Revert(
1830   IStorage* iface)
1831 {
1832   TRACE("(%p)\n", iface);
1833   return S_OK;
1834 }
1835
1836 /*************************************************************************
1837  * DestroyElement (IStorage)
1838  *
1839  * Strategy: This implementation is built this way for simplicity not for speed.
1840  *          I always delete the topmost element of the enumeration and adjust
1841  *          the deleted element pointer all the time.  This takes longer to
1842  *          do but allow to reinvoke DestroyElement whenever we encounter a
1843  *          storage object.  The optimisation resides in the usage of another
1844  *          enumeration strategy that would give all the leaves of a storage
1845  *          first. (postfix order)
1846  */
1847 static HRESULT WINAPI StorageBaseImpl_DestroyElement(
1848   IStorage*     iface,
1849   const OLECHAR *pwcsName)/* [string][in] */
1850 {
1851   StorageBaseImpl* const This=(StorageBaseImpl*)iface;
1852
1853   HRESULT           hr = S_OK;
1854   DirEntry          entryToDelete;
1855   DirRef            entryToDeleteRef;
1856
1857   TRACE("(%p, %s)\n",
1858         iface, debugstr_w(pwcsName));
1859
1860   if (pwcsName==NULL)
1861     return STG_E_INVALIDPOINTER;
1862
1863   if (This->reverted)
1864     return STG_E_REVERTED;
1865
1866   if ( !(This->openFlags & STGM_TRANSACTED) &&
1867        STGM_ACCESS_MODE( This->openFlags ) == STGM_READ )
1868     return STG_E_ACCESSDENIED;
1869
1870   entryToDeleteRef = findElement(
1871     This,
1872     This->storageDirEntry,
1873     pwcsName,
1874     &entryToDelete);
1875
1876   if ( entryToDeleteRef == DIRENTRY_NULL )
1877   {
1878     return STG_E_FILENOTFOUND;
1879   }
1880
1881   if ( entryToDelete.stgType == STGTY_STORAGE )
1882   {
1883     hr = deleteStorageContents(
1884            This,
1885            entryToDeleteRef,
1886            entryToDelete);
1887   }
1888   else if ( entryToDelete.stgType == STGTY_STREAM )
1889   {
1890     hr = deleteStreamContents(
1891            This,
1892            entryToDeleteRef,
1893            entryToDelete);
1894   }
1895
1896   if (hr!=S_OK)
1897     return hr;
1898
1899   /*
1900    * Remove the entry from its parent storage
1901    */
1902   hr = removeFromTree(
1903         This,
1904         This->storageDirEntry,
1905         entryToDeleteRef);
1906
1907   /*
1908    * Invalidate the entry
1909    */
1910   if (SUCCEEDED(hr))
1911     StorageBaseImpl_DestroyDirEntry(This, entryToDeleteRef);
1912
1913   return hr;
1914 }
1915
1916
1917 /******************************************************************************
1918  * Internal stream list handlers
1919  */
1920
1921 void StorageBaseImpl_AddStream(StorageBaseImpl * stg, StgStreamImpl * strm)
1922 {
1923   TRACE("Stream added (stg=%p strm=%p)\n", stg, strm);
1924   list_add_tail(&stg->strmHead,&strm->StrmListEntry);
1925 }
1926
1927 void StorageBaseImpl_RemoveStream(StorageBaseImpl * stg, StgStreamImpl * strm)
1928 {
1929   TRACE("Stream removed (stg=%p strm=%p)\n", stg,strm);
1930   list_remove(&(strm->StrmListEntry));
1931 }
1932
1933 static BOOL StorageBaseImpl_IsStreamOpen(StorageBaseImpl * stg, DirRef streamEntry)
1934 {
1935   StgStreamImpl *strm;
1936
1937   LIST_FOR_EACH_ENTRY(strm, &stg->strmHead, StgStreamImpl, StrmListEntry)
1938   {
1939     if (strm->dirEntry == streamEntry)
1940     {
1941       return TRUE;
1942     }
1943   }
1944
1945   return FALSE;
1946 }
1947
1948 static BOOL StorageBaseImpl_IsStorageOpen(StorageBaseImpl * stg, DirRef storageEntry)
1949 {
1950   StorageInternalImpl *childstg;
1951
1952   LIST_FOR_EACH_ENTRY(childstg, &stg->storageHead, StorageInternalImpl, ParentListEntry)
1953   {
1954     if (childstg->base.storageDirEntry == storageEntry)
1955     {
1956       return TRUE;
1957     }
1958   }
1959
1960   return FALSE;
1961 }
1962
1963 static void StorageBaseImpl_DeleteAll(StorageBaseImpl * stg)
1964 {
1965   struct list *cur, *cur2;
1966   StgStreamImpl *strm=NULL;
1967   StorageInternalImpl *childstg=NULL;
1968
1969   LIST_FOR_EACH_SAFE(cur, cur2, &stg->strmHead) {
1970     strm = LIST_ENTRY(cur,StgStreamImpl,StrmListEntry);
1971     TRACE("Streams invalidated (stg=%p strm=%p next=%p prev=%p)\n", stg,strm,cur->next,cur->prev);
1972     strm->parentStorage = NULL;
1973     list_remove(cur);
1974   }
1975
1976   LIST_FOR_EACH_SAFE(cur, cur2, &stg->storageHead) {
1977     childstg = LIST_ENTRY(cur,StorageInternalImpl,ParentListEntry);
1978     StorageBaseImpl_Invalidate( &childstg->base );
1979   }
1980
1981   if (stg->transactedChild)
1982   {
1983     StorageBaseImpl_Invalidate(stg->transactedChild);
1984
1985     stg->transactedChild = NULL;
1986   }
1987 }
1988
1989
1990 /*********************************************************************
1991  *
1992  * Internal Method
1993  *
1994  * Delete the contents of a storage entry.
1995  *
1996  */
1997 static HRESULT deleteStorageContents(
1998   StorageBaseImpl *parentStorage,
1999   DirRef       indexToDelete,
2000   DirEntry     entryDataToDelete)
2001 {
2002   IEnumSTATSTG *elements     = 0;
2003   IStorage   *childStorage = 0;
2004   STATSTG      currentElement;
2005   HRESULT      hr;
2006   HRESULT      destroyHr = S_OK;
2007   StorageInternalImpl *stg, *stg2;
2008
2009   /* Invalidate any open storage objects. */
2010   LIST_FOR_EACH_ENTRY_SAFE(stg, stg2, &parentStorage->storageHead, StorageInternalImpl, ParentListEntry)
2011   {
2012     if (stg->base.storageDirEntry == indexToDelete)
2013     {
2014       StorageBaseImpl_Invalidate(&stg->base);
2015     }
2016   }
2017
2018   /*
2019    * Open the storage and enumerate it
2020    */
2021   hr = StorageBaseImpl_OpenStorage(
2022         (IStorage*)parentStorage,
2023         entryDataToDelete.name,
2024         0,
2025         STGM_WRITE | STGM_SHARE_EXCLUSIVE,
2026         0,
2027         0,
2028         &childStorage);
2029
2030   if (hr != S_OK)
2031   {
2032     return hr;
2033   }
2034
2035   /*
2036    * Enumerate the elements
2037    */
2038   IStorage_EnumElements( childStorage, 0, 0, 0, &elements);
2039
2040   do
2041   {
2042     /*
2043      * Obtain the next element
2044      */
2045     hr = IEnumSTATSTG_Next(elements, 1, &currentElement, NULL);
2046     if (hr==S_OK)
2047     {
2048       destroyHr = IStorage_DestroyElement(childStorage, currentElement.pwcsName);
2049
2050       CoTaskMemFree(currentElement.pwcsName);
2051     }
2052
2053     /*
2054      * We need to Reset the enumeration every time because we delete elements
2055      * and the enumeration could be invalid
2056      */
2057     IEnumSTATSTG_Reset(elements);
2058
2059   } while ((hr == S_OK) && (destroyHr == S_OK));
2060
2061   IStorage_Release(childStorage);
2062   IEnumSTATSTG_Release(elements);
2063
2064   return destroyHr;
2065 }
2066
2067 /*********************************************************************
2068  *
2069  * Internal Method
2070  *
2071  * Perform the deletion of a stream's data
2072  *
2073  */
2074 static HRESULT deleteStreamContents(
2075   StorageBaseImpl *parentStorage,
2076   DirRef        indexToDelete,
2077   DirEntry      entryDataToDelete)
2078 {
2079   IStream      *pis;
2080   HRESULT        hr;
2081   ULARGE_INTEGER size;
2082   StgStreamImpl *strm, *strm2;
2083
2084   /* Invalidate any open stream objects. */
2085   LIST_FOR_EACH_ENTRY_SAFE(strm, strm2, &parentStorage->strmHead, StgStreamImpl, StrmListEntry)
2086   {
2087     if (strm->dirEntry == indexToDelete)
2088     {
2089       TRACE("Stream deleted %p\n", strm);
2090       strm->parentStorage = NULL;
2091       list_remove(&strm->StrmListEntry);
2092     }
2093   }
2094
2095   size.u.HighPart = 0;
2096   size.u.LowPart = 0;
2097
2098   hr = StorageBaseImpl_OpenStream((IStorage*)parentStorage,
2099         entryDataToDelete.name, NULL, STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, &pis);
2100
2101   if (hr!=S_OK)
2102   {
2103     return(hr);
2104   }
2105
2106   /*
2107    * Zap the stream
2108    */
2109   hr = IStream_SetSize(pis, size);
2110
2111   if(hr != S_OK)
2112   {
2113     return hr;
2114   }
2115
2116   /*
2117    * Release the stream object.
2118    */
2119   IStream_Release(pis);
2120
2121   return S_OK;
2122 }
2123
2124 static void setEntryLink(DirEntry *entry, ULONG relation, DirRef new_target)
2125 {
2126   switch (relation)
2127   {
2128     case DIRENTRY_RELATION_PREVIOUS:
2129       entry->leftChild = new_target;
2130       break;
2131     case DIRENTRY_RELATION_NEXT:
2132       entry->rightChild = new_target;
2133       break;
2134     case DIRENTRY_RELATION_DIR:
2135       entry->dirRootEntry = new_target;
2136       break;
2137     default:
2138       assert(0);
2139   }
2140 }
2141
2142 /*************************************************************************
2143  *
2144  * Internal Method
2145  *
2146  * This method removes a directory entry from its parent storage tree without
2147  * freeing any resources attached to it.
2148  */
2149 static HRESULT removeFromTree(
2150   StorageBaseImpl *This,
2151   DirRef        parentStorageIndex,
2152   DirRef        deletedIndex)
2153 {
2154   HRESULT hr                     = S_OK;
2155   DirEntry   entryToDelete;
2156   DirEntry   parentEntry;
2157   DirRef parentEntryRef;
2158   ULONG typeOfRelation;
2159
2160   hr = StorageBaseImpl_ReadDirEntry(This, deletedIndex, &entryToDelete);
2161
2162   if (hr != S_OK)
2163     return hr;
2164
2165   /*
2166    * Find the element that links to the one we want to delete.
2167    */
2168   hr = findTreeParent(This, parentStorageIndex, entryToDelete.name,
2169     &parentEntry, &parentEntryRef, &typeOfRelation);
2170
2171   if (hr != S_OK)
2172     return hr;
2173
2174   if (entryToDelete.leftChild != DIRENTRY_NULL)
2175   {
2176     /*
2177      * Replace the deleted entry with its left child
2178      */
2179     setEntryLink(&parentEntry, typeOfRelation, entryToDelete.leftChild);
2180
2181     hr = StorageBaseImpl_WriteDirEntry(
2182             This,
2183             parentEntryRef,
2184             &parentEntry);
2185     if(FAILED(hr))
2186     {
2187       return hr;
2188     }
2189
2190     if (entryToDelete.rightChild != DIRENTRY_NULL)
2191     {
2192       /*
2193        * We need to reinsert the right child somewhere. We already know it and
2194        * its children are greater than everything in the left tree, so we
2195        * insert it at the rightmost point in the left tree.
2196        */
2197       DirRef newRightChildParent = entryToDelete.leftChild;
2198       DirEntry newRightChildParentEntry;
2199
2200       do
2201       {
2202         hr = StorageBaseImpl_ReadDirEntry(
2203                 This,
2204                 newRightChildParent,
2205                 &newRightChildParentEntry);
2206         if (FAILED(hr))
2207         {
2208           return hr;
2209         }
2210
2211         if (newRightChildParentEntry.rightChild != DIRENTRY_NULL)
2212           newRightChildParent = newRightChildParentEntry.rightChild;
2213       } while (newRightChildParentEntry.rightChild != DIRENTRY_NULL);
2214
2215       newRightChildParentEntry.rightChild = entryToDelete.rightChild;
2216
2217       hr = StorageBaseImpl_WriteDirEntry(
2218               This,
2219               newRightChildParent,
2220               &newRightChildParentEntry);
2221       if (FAILED(hr))
2222       {
2223         return hr;
2224       }
2225     }
2226   }
2227   else
2228   {
2229     /*
2230      * Replace the deleted entry with its right child
2231      */
2232     setEntryLink(&parentEntry, typeOfRelation, entryToDelete.rightChild);
2233
2234     hr = StorageBaseImpl_WriteDirEntry(
2235             This,
2236             parentEntryRef,
2237             &parentEntry);
2238     if(FAILED(hr))
2239     {
2240       return hr;
2241     }
2242   }
2243
2244   return hr;
2245 }
2246
2247
2248 /******************************************************************************
2249  * SetElementTimes (IStorage)
2250  */
2251 static HRESULT WINAPI StorageBaseImpl_SetElementTimes(
2252   IStorage*     iface,
2253   const OLECHAR *pwcsName,/* [string][in] */
2254   const FILETIME  *pctime,  /* [in] */
2255   const FILETIME  *patime,  /* [in] */
2256   const FILETIME  *pmtime)  /* [in] */
2257 {
2258   FIXME("(%s,...), stub!\n",debugstr_w(pwcsName));
2259   return S_OK;
2260 }
2261
2262 /******************************************************************************
2263  * SetStateBits (IStorage)
2264  */
2265 static HRESULT WINAPI StorageBaseImpl_SetStateBits(
2266   IStorage*   iface,
2267   DWORD         grfStateBits,/* [in] */
2268   DWORD         grfMask)     /* [in] */
2269 {
2270   StorageBaseImpl* const This = (StorageBaseImpl*)iface;
2271
2272   if (This->reverted)
2273     return STG_E_REVERTED;
2274
2275   This->stateBits = (This->stateBits & ~grfMask) | (grfStateBits & grfMask);
2276   return S_OK;
2277 }
2278
2279 static HRESULT StorageImpl_BaseWriteDirEntry(StorageBaseImpl *base,
2280   DirRef index, const DirEntry *data)
2281 {
2282   StorageImpl *This = (StorageImpl*)base;
2283   return StorageImpl_WriteDirEntry(This, index, data);
2284 }
2285
2286 static HRESULT StorageImpl_BaseReadDirEntry(StorageBaseImpl *base,
2287   DirRef index, DirEntry *data)
2288 {
2289   StorageImpl *This = (StorageImpl*)base;
2290   return StorageImpl_ReadDirEntry(This, index, data);
2291 }
2292
2293 static BlockChainStream **StorageImpl_GetFreeBlockChainCacheEntry(StorageImpl* This)
2294 {
2295   int i;
2296
2297   for (i=0; i<BLOCKCHAIN_CACHE_SIZE; i++)
2298   {
2299     if (!This->blockChainCache[i])
2300     {
2301       return &This->blockChainCache[i];
2302     }
2303   }
2304
2305   i = This->blockChainToEvict;
2306
2307   BlockChainStream_Destroy(This->blockChainCache[i]);
2308   This->blockChainCache[i] = NULL;
2309
2310   This->blockChainToEvict++;
2311   if (This->blockChainToEvict == BLOCKCHAIN_CACHE_SIZE)
2312     This->blockChainToEvict = 0;
2313
2314   return &This->blockChainCache[i];
2315 }
2316
2317 static BlockChainStream **StorageImpl_GetCachedBlockChainStream(StorageImpl *This,
2318     DirRef index)
2319 {
2320   int i, free_index=-1;
2321
2322   for (i=0; i<BLOCKCHAIN_CACHE_SIZE; i++)
2323   {
2324     if (!This->blockChainCache[i])
2325     {
2326       if (free_index == -1) free_index = i;
2327     }
2328     else if (This->blockChainCache[i]->ownerDirEntry == index)
2329     {
2330       return &This->blockChainCache[i];
2331     }
2332   }
2333
2334   if (free_index == -1)
2335   {
2336     free_index = This->blockChainToEvict;
2337
2338     BlockChainStream_Destroy(This->blockChainCache[free_index]);
2339     This->blockChainCache[free_index] = NULL;
2340
2341     This->blockChainToEvict++;
2342     if (This->blockChainToEvict == BLOCKCHAIN_CACHE_SIZE)
2343       This->blockChainToEvict = 0;
2344   }
2345
2346   This->blockChainCache[free_index] = BlockChainStream_Construct(This, NULL, index);
2347   return &This->blockChainCache[free_index];
2348 }
2349
2350 static HRESULT StorageImpl_StreamReadAt(StorageBaseImpl *base, DirRef index,
2351   ULARGE_INTEGER offset, ULONG size, void *buffer, ULONG *bytesRead)
2352 {
2353   StorageImpl *This = (StorageImpl*)base;
2354   DirEntry data;
2355   HRESULT hr;
2356   ULONG bytesToRead;
2357
2358   hr = StorageImpl_ReadDirEntry(This, index, &data);
2359   if (FAILED(hr)) return hr;
2360
2361   if (data.size.QuadPart == 0)
2362   {
2363     *bytesRead = 0;
2364     return S_OK;
2365   }
2366
2367   if (offset.QuadPart + size > data.size.QuadPart)
2368   {
2369     bytesToRead = data.size.QuadPart - offset.QuadPart;
2370   }
2371   else
2372   {
2373     bytesToRead = size;
2374   }
2375
2376   if (data.size.QuadPart < LIMIT_TO_USE_SMALL_BLOCK)
2377   {
2378     SmallBlockChainStream *stream;
2379
2380     stream = SmallBlockChainStream_Construct(This, NULL, index);
2381     if (!stream) return E_OUTOFMEMORY;
2382
2383     hr = SmallBlockChainStream_ReadAt(stream, offset, bytesToRead, buffer, bytesRead);
2384
2385     SmallBlockChainStream_Destroy(stream);
2386
2387     return hr;
2388   }
2389   else
2390   {
2391     BlockChainStream *stream = NULL;
2392
2393     stream = *StorageImpl_GetCachedBlockChainStream(This, index);
2394     if (!stream) return E_OUTOFMEMORY;
2395
2396     hr = BlockChainStream_ReadAt(stream, offset, bytesToRead, buffer, bytesRead);
2397
2398     return hr;
2399   }
2400 }
2401
2402 static HRESULT StorageImpl_StreamSetSize(StorageBaseImpl *base, DirRef index,
2403   ULARGE_INTEGER newsize)
2404 {
2405   StorageImpl *This = (StorageImpl*)base;
2406   DirEntry data;
2407   HRESULT hr;
2408   SmallBlockChainStream *smallblock=NULL;
2409   BlockChainStream **pbigblock=NULL, *bigblock=NULL;
2410
2411   hr = StorageImpl_ReadDirEntry(This, index, &data);
2412   if (FAILED(hr)) return hr;
2413
2414   /* In simple mode keep the stream size above the small block limit */
2415   if (This->base.openFlags & STGM_SIMPLE)
2416     newsize.QuadPart = max(newsize.QuadPart, LIMIT_TO_USE_SMALL_BLOCK);
2417
2418   if (data.size.QuadPart == newsize.QuadPart)
2419     return S_OK;
2420
2421   /* Create a block chain object of the appropriate type */
2422   if (data.size.QuadPart == 0)
2423   {
2424     if (newsize.QuadPart < LIMIT_TO_USE_SMALL_BLOCK)
2425     {
2426       smallblock = SmallBlockChainStream_Construct(This, NULL, index);
2427       if (!smallblock) return E_OUTOFMEMORY;
2428     }
2429     else
2430     {
2431       pbigblock = StorageImpl_GetCachedBlockChainStream(This, index);
2432       bigblock = *pbigblock;
2433       if (!bigblock) return E_OUTOFMEMORY;
2434     }
2435   }
2436   else if (data.size.QuadPart < LIMIT_TO_USE_SMALL_BLOCK)
2437   {
2438     smallblock = SmallBlockChainStream_Construct(This, NULL, index);
2439     if (!smallblock) return E_OUTOFMEMORY;
2440   }
2441   else
2442   {
2443     pbigblock = StorageImpl_GetCachedBlockChainStream(This, index);
2444     bigblock = *pbigblock;
2445     if (!bigblock) return E_OUTOFMEMORY;
2446   }
2447
2448   /* Change the block chain type if necessary. */
2449   if (smallblock && newsize.QuadPart >= LIMIT_TO_USE_SMALL_BLOCK)
2450   {
2451     bigblock = Storage32Impl_SmallBlocksToBigBlocks(This, &smallblock);
2452     if (!bigblock)
2453     {
2454       SmallBlockChainStream_Destroy(smallblock);
2455       return E_FAIL;
2456     }
2457
2458     pbigblock = StorageImpl_GetFreeBlockChainCacheEntry(This);
2459     *pbigblock = bigblock;
2460   }
2461   else if (bigblock && newsize.QuadPart < LIMIT_TO_USE_SMALL_BLOCK)
2462   {
2463     smallblock = Storage32Impl_BigBlocksToSmallBlocks(This, pbigblock);
2464     if (!smallblock)
2465       return E_FAIL;
2466   }
2467
2468   /* Set the size of the block chain. */
2469   if (smallblock)
2470   {
2471     SmallBlockChainStream_SetSize(smallblock, newsize);
2472     SmallBlockChainStream_Destroy(smallblock);
2473   }
2474   else
2475   {
2476     BlockChainStream_SetSize(bigblock, newsize);
2477   }
2478
2479   /* Set the size in the directory entry. */
2480   hr = StorageImpl_ReadDirEntry(This, index, &data);
2481   if (SUCCEEDED(hr))
2482   {
2483     data.size = newsize;
2484
2485     hr = StorageImpl_WriteDirEntry(This, index, &data);
2486   }
2487   return hr;
2488 }
2489
2490 static HRESULT StorageImpl_StreamWriteAt(StorageBaseImpl *base, DirRef index,
2491   ULARGE_INTEGER offset, ULONG size, const void *buffer, ULONG *bytesWritten)
2492 {
2493   StorageImpl *This = (StorageImpl*)base;
2494   DirEntry data;
2495   HRESULT hr;
2496   ULARGE_INTEGER newSize;
2497
2498   hr = StorageImpl_ReadDirEntry(This, index, &data);
2499   if (FAILED(hr)) return hr;
2500
2501   /* Grow the stream if necessary */
2502   newSize.QuadPart = 0;
2503   newSize.QuadPart = offset.QuadPart + size;
2504
2505   if (newSize.QuadPart > data.size.QuadPart)
2506   {
2507     hr = StorageImpl_StreamSetSize(base, index, newSize);
2508     if (FAILED(hr))
2509       return hr;
2510
2511     hr = StorageImpl_ReadDirEntry(This, index, &data);
2512     if (FAILED(hr)) return hr;
2513   }
2514
2515   if (data.size.QuadPart < LIMIT_TO_USE_SMALL_BLOCK)
2516   {
2517     SmallBlockChainStream *stream;
2518
2519     stream = SmallBlockChainStream_Construct(This, NULL, index);
2520     if (!stream) return E_OUTOFMEMORY;
2521
2522     hr = SmallBlockChainStream_WriteAt(stream, offset, size, buffer, bytesWritten);
2523
2524     SmallBlockChainStream_Destroy(stream);
2525
2526     return hr;
2527   }
2528   else
2529   {
2530     BlockChainStream *stream;
2531
2532     stream = *StorageImpl_GetCachedBlockChainStream(This, index);
2533     if (!stream) return E_OUTOFMEMORY;
2534
2535     hr = BlockChainStream_WriteAt(stream, offset, size, buffer, bytesWritten);
2536
2537     return hr;
2538   }
2539 }
2540
2541 /*
2542  * Virtual function table for the IStorage32Impl class.
2543  */
2544 static const IStorageVtbl Storage32Impl_Vtbl =
2545 {
2546     StorageBaseImpl_QueryInterface,
2547     StorageBaseImpl_AddRef,
2548     StorageBaseImpl_Release,
2549     StorageBaseImpl_CreateStream,
2550     StorageBaseImpl_OpenStream,
2551     StorageBaseImpl_CreateStorage,
2552     StorageBaseImpl_OpenStorage,
2553     StorageBaseImpl_CopyTo,
2554     StorageBaseImpl_MoveElementTo,
2555     StorageImpl_Commit,
2556     StorageImpl_Revert,
2557     StorageBaseImpl_EnumElements,
2558     StorageBaseImpl_DestroyElement,
2559     StorageBaseImpl_RenameElement,
2560     StorageBaseImpl_SetElementTimes,
2561     StorageBaseImpl_SetClass,
2562     StorageBaseImpl_SetStateBits,
2563     StorageBaseImpl_Stat
2564 };
2565
2566 static const StorageBaseImplVtbl StorageImpl_BaseVtbl =
2567 {
2568   StorageImpl_Destroy,
2569   StorageImpl_Invalidate,
2570   StorageImpl_CreateDirEntry,
2571   StorageImpl_BaseWriteDirEntry,
2572   StorageImpl_BaseReadDirEntry,
2573   StorageImpl_DestroyDirEntry,
2574   StorageImpl_StreamReadAt,
2575   StorageImpl_StreamWriteAt,
2576   StorageImpl_StreamSetSize
2577 };
2578
2579 static HRESULT StorageImpl_Construct(
2580   HANDLE       hFile,
2581   LPCOLESTR    pwcsName,
2582   ILockBytes*  pLkbyt,
2583   DWORD        openFlags,
2584   BOOL         fileBased,
2585   BOOL         create,
2586   StorageImpl** result)
2587 {
2588   StorageImpl* This;
2589   HRESULT     hr = S_OK;
2590   DirEntry currentEntry;
2591   DirRef      currentEntryRef;
2592   WCHAR fullpath[MAX_PATH];
2593
2594   if ( FAILED( validateSTGM(openFlags) ))
2595     return STG_E_INVALIDFLAG;
2596
2597   This = HeapAlloc(GetProcessHeap(), 0, sizeof(StorageImpl));
2598   if (!This)
2599     return E_OUTOFMEMORY;
2600
2601   memset(This, 0, sizeof(StorageImpl));
2602
2603   list_init(&This->base.strmHead);
2604
2605   list_init(&This->base.storageHead);
2606
2607   This->base.lpVtbl = &Storage32Impl_Vtbl;
2608   This->base.pssVtbl = &IPropertySetStorage_Vtbl;
2609   This->base.baseVtbl = &StorageImpl_BaseVtbl;
2610   This->base.openFlags = (openFlags & ~STGM_CREATE);
2611   This->base.ref = 1;
2612   This->base.create = create;
2613
2614   This->base.reverted = 0;
2615
2616   This->hFile = hFile;
2617
2618   if(pwcsName) {
2619       if (!GetFullPathNameW(pwcsName, MAX_PATH, fullpath, NULL))
2620       {
2621         lstrcpynW(fullpath, pwcsName, MAX_PATH);
2622       }
2623       This->pwcsName = HeapAlloc(GetProcessHeap(), 0,
2624                                 (lstrlenW(fullpath)+1)*sizeof(WCHAR));
2625       if (!This->pwcsName)
2626       {
2627          hr = STG_E_INSUFFICIENTMEMORY;
2628          goto end;
2629       }
2630       strcpyW(This->pwcsName, fullpath);
2631       This->base.filename = This->pwcsName;
2632   }
2633
2634   /*
2635    * Initialize the big block cache.
2636    */
2637   This->bigBlockSize   = DEF_BIG_BLOCK_SIZE;
2638   This->smallBlockSize = DEF_SMALL_BLOCK_SIZE;
2639   This->bigBlockFile   = BIGBLOCKFILE_Construct(hFile,
2640                                                 pLkbyt,
2641                                                 openFlags,
2642                                                 fileBased);
2643
2644   if (This->bigBlockFile == 0)
2645   {
2646     hr = E_FAIL;
2647     goto end;
2648   }
2649
2650   if (create)
2651   {
2652     ULARGE_INTEGER size;
2653     BYTE bigBlockBuffer[MAX_BIG_BLOCK_SIZE];
2654
2655     /*
2656      * Initialize all header variables:
2657      * - The big block depot consists of one block and it is at block 0
2658      * - The directory table starts at block 1
2659      * - There is no small block depot
2660      */
2661     memset( This->bigBlockDepotStart,
2662             BLOCK_UNUSED,
2663             sizeof(This->bigBlockDepotStart));
2664
2665     This->bigBlockDepotCount    = 1;
2666     This->bigBlockDepotStart[0] = 0;
2667     This->rootStartBlock        = 1;
2668     This->smallBlockDepotStart  = BLOCK_END_OF_CHAIN;
2669     This->bigBlockSizeBits      = DEF_BIG_BLOCK_SIZE_BITS;
2670     This->smallBlockSizeBits    = DEF_SMALL_BLOCK_SIZE_BITS;
2671     This->extBigBlockDepotStart = BLOCK_END_OF_CHAIN;
2672     This->extBigBlockDepotCount = 0;
2673
2674     StorageImpl_SaveFileHeader(This);
2675
2676     /*
2677      * Add one block for the big block depot and one block for the directory table
2678      */
2679     size.u.HighPart = 0;
2680     size.u.LowPart  = This->bigBlockSize * 3;
2681     BIGBLOCKFILE_SetSize(This->bigBlockFile, size);
2682
2683     /*
2684      * Initialize the big block depot
2685      */
2686     memset(bigBlockBuffer, BLOCK_UNUSED, This->bigBlockSize);
2687     StorageUtl_WriteDWord(bigBlockBuffer, 0, BLOCK_SPECIAL);
2688     StorageUtl_WriteDWord(bigBlockBuffer, sizeof(ULONG), BLOCK_END_OF_CHAIN);
2689     StorageImpl_WriteBigBlock(This, 0, bigBlockBuffer);
2690   }
2691   else
2692   {
2693     /*
2694      * Load the header for the file.
2695      */
2696     hr = StorageImpl_LoadFileHeader(This);
2697
2698     if (FAILED(hr))
2699     {
2700       goto end;
2701     }
2702   }
2703
2704   /*
2705    * There is no block depot cached yet.
2706    */
2707   This->indexBlockDepotCached = 0xFFFFFFFF;
2708
2709   /*
2710    * Start searching for free blocks with block 0.
2711    */
2712   This->prevFreeBlock = 0;
2713
2714   /*
2715    * Create the block chain abstractions.
2716    */
2717   if(!(This->rootBlockChain =
2718        BlockChainStream_Construct(This, &This->rootStartBlock, DIRENTRY_NULL)))
2719   {
2720     hr = STG_E_READFAULT;
2721     goto end;
2722   }
2723
2724   if(!(This->smallBlockDepotChain =
2725        BlockChainStream_Construct(This, &This->smallBlockDepotStart,
2726                                   DIRENTRY_NULL)))
2727   {
2728     hr = STG_E_READFAULT;
2729     goto end;
2730   }
2731
2732   /*
2733    * Write the root storage entry (memory only)
2734    */
2735   if (create)
2736   {
2737     DirEntry rootEntry;
2738     /*
2739      * Initialize the directory table
2740      */
2741     memset(&rootEntry, 0, sizeof(rootEntry));
2742     MultiByteToWideChar( CP_ACP, 0, rootEntryName, -1, rootEntry.name,
2743                          sizeof(rootEntry.name)/sizeof(WCHAR) );
2744     rootEntry.sizeOfNameString = (strlenW(rootEntry.name)+1) * sizeof(WCHAR);
2745     rootEntry.stgType          = STGTY_ROOT;
2746     rootEntry.leftChild = DIRENTRY_NULL;
2747     rootEntry.rightChild     = DIRENTRY_NULL;
2748     rootEntry.dirRootEntry     = DIRENTRY_NULL;
2749     rootEntry.startingBlock    = BLOCK_END_OF_CHAIN;
2750     rootEntry.size.u.HighPart    = 0;
2751     rootEntry.size.u.LowPart     = 0;
2752
2753     StorageImpl_WriteDirEntry(This, 0, &rootEntry);
2754   }
2755
2756   /*
2757    * Find the ID of the root storage.
2758    */
2759   currentEntryRef = 0;
2760
2761   do
2762   {
2763     hr = StorageImpl_ReadDirEntry(
2764                       This,
2765                       currentEntryRef,
2766                       &currentEntry);
2767
2768     if (SUCCEEDED(hr))
2769     {
2770       if ( (currentEntry.sizeOfNameString != 0 ) &&
2771            (currentEntry.stgType          == STGTY_ROOT) )
2772       {
2773         This->base.storageDirEntry = currentEntryRef;
2774       }
2775     }
2776
2777     currentEntryRef++;
2778
2779   } while (SUCCEEDED(hr) && (This->base.storageDirEntry == DIRENTRY_NULL) );
2780
2781   if (FAILED(hr))
2782   {
2783     hr = STG_E_READFAULT;
2784     goto end;
2785   }
2786
2787   /*
2788    * Create the block chain abstraction for the small block root chain.
2789    */
2790   if(!(This->smallBlockRootChain =
2791        BlockChainStream_Construct(This, NULL, This->base.storageDirEntry)))
2792   {
2793     hr = STG_E_READFAULT;
2794   }
2795
2796 end:
2797   if (FAILED(hr))
2798   {
2799     IStorage_Release((IStorage*)This);
2800     *result = NULL;
2801   }
2802   else
2803     *result = This;
2804
2805   return hr;
2806 }
2807
2808 static void StorageImpl_Invalidate(StorageBaseImpl* iface)
2809 {
2810   StorageImpl *This = (StorageImpl*) iface;
2811
2812   StorageBaseImpl_DeleteAll(&This->base);
2813
2814   This->base.reverted = 1;
2815 }
2816
2817 static void StorageImpl_Destroy(StorageBaseImpl* iface)
2818 {
2819   StorageImpl *This = (StorageImpl*) iface;
2820   int i;
2821   TRACE("(%p)\n", This);
2822
2823   StorageImpl_Invalidate(iface);
2824
2825   HeapFree(GetProcessHeap(), 0, This->pwcsName);
2826
2827   BlockChainStream_Destroy(This->smallBlockRootChain);
2828   BlockChainStream_Destroy(This->rootBlockChain);
2829   BlockChainStream_Destroy(This->smallBlockDepotChain);
2830
2831   for (i=0; i<BLOCKCHAIN_CACHE_SIZE; i++)
2832     BlockChainStream_Destroy(This->blockChainCache[i]);
2833
2834   if (This->bigBlockFile)
2835     BIGBLOCKFILE_Destructor(This->bigBlockFile);
2836   HeapFree(GetProcessHeap(), 0, This);
2837 }
2838
2839 /******************************************************************************
2840  *      Storage32Impl_GetNextFreeBigBlock
2841  *
2842  * Returns the index of the next free big block.
2843  * If the big block depot is filled, this method will enlarge it.
2844  *
2845  */
2846 static ULONG StorageImpl_GetNextFreeBigBlock(
2847   StorageImpl* This)
2848 {
2849   ULONG depotBlockIndexPos;
2850   BYTE depotBuffer[MAX_BIG_BLOCK_SIZE];
2851   BOOL success;
2852   ULONG depotBlockOffset;
2853   ULONG blocksPerDepot    = This->bigBlockSize / sizeof(ULONG);
2854   ULONG nextBlockIndex    = BLOCK_SPECIAL;
2855   int   depotIndex        = 0;
2856   ULONG freeBlock         = BLOCK_UNUSED;
2857   ULARGE_INTEGER neededSize;
2858
2859   depotIndex = This->prevFreeBlock / blocksPerDepot;
2860   depotBlockOffset = (This->prevFreeBlock % blocksPerDepot) * sizeof(ULONG);
2861
2862   /*
2863    * Scan the entire big block depot until we find a block marked free
2864    */
2865   while (nextBlockIndex != BLOCK_UNUSED)
2866   {
2867     if (depotIndex < COUNT_BBDEPOTINHEADER)
2868     {
2869       depotBlockIndexPos = This->bigBlockDepotStart[depotIndex];
2870
2871       /*
2872        * Grow the primary depot.
2873        */
2874       if (depotBlockIndexPos == BLOCK_UNUSED)
2875       {
2876         depotBlockIndexPos = depotIndex*blocksPerDepot;
2877
2878         /*
2879          * Add a block depot.
2880          */
2881         Storage32Impl_AddBlockDepot(This, depotBlockIndexPos);
2882         This->bigBlockDepotCount++;
2883         This->bigBlockDepotStart[depotIndex] = depotBlockIndexPos;
2884
2885         /*
2886          * Flag it as a block depot.
2887          */
2888         StorageImpl_SetNextBlockInChain(This,
2889                                           depotBlockIndexPos,
2890                                           BLOCK_SPECIAL);
2891
2892         /* Save new header information.
2893          */
2894         StorageImpl_SaveFileHeader(This);
2895       }
2896     }
2897     else
2898     {
2899       depotBlockIndexPos = Storage32Impl_GetExtDepotBlock(This, depotIndex);
2900
2901       if (depotBlockIndexPos == BLOCK_UNUSED)
2902       {
2903         /*
2904          * Grow the extended depot.
2905          */
2906         ULONG extIndex       = BLOCK_UNUSED;
2907         ULONG numExtBlocks   = depotIndex - COUNT_BBDEPOTINHEADER;
2908         ULONG extBlockOffset = numExtBlocks % (blocksPerDepot - 1);
2909
2910         if (extBlockOffset == 0)
2911         {
2912           /* We need an extended block.
2913            */
2914           extIndex = Storage32Impl_AddExtBlockDepot(This);
2915           This->extBigBlockDepotCount++;
2916           depotBlockIndexPos = extIndex + 1;
2917         }
2918         else
2919           depotBlockIndexPos = depotIndex * blocksPerDepot;
2920
2921         /*
2922          * Add a block depot and mark it in the extended block.
2923          */
2924         Storage32Impl_AddBlockDepot(This, depotBlockIndexPos);
2925         This->bigBlockDepotCount++;
2926         Storage32Impl_SetExtDepotBlock(This, depotIndex, depotBlockIndexPos);
2927
2928         /* Flag the block depot.
2929          */
2930         StorageImpl_SetNextBlockInChain(This,
2931                                           depotBlockIndexPos,
2932                                           BLOCK_SPECIAL);
2933
2934         /* If necessary, flag the extended depot block.
2935          */
2936         if (extIndex != BLOCK_UNUSED)
2937           StorageImpl_SetNextBlockInChain(This, extIndex, BLOCK_EXTBBDEPOT);
2938
2939         /* Save header information.
2940          */
2941         StorageImpl_SaveFileHeader(This);
2942       }
2943     }
2944
2945     success = StorageImpl_ReadBigBlock(This, depotBlockIndexPos, depotBuffer);
2946
2947     if (success)
2948     {
2949       while ( ( (depotBlockOffset/sizeof(ULONG) ) < blocksPerDepot) &&
2950               ( nextBlockIndex != BLOCK_UNUSED))
2951       {
2952         StorageUtl_ReadDWord(depotBuffer, depotBlockOffset, &nextBlockIndex);
2953
2954         if (nextBlockIndex == BLOCK_UNUSED)
2955         {
2956           freeBlock = (depotIndex * blocksPerDepot) +
2957                       (depotBlockOffset/sizeof(ULONG));
2958         }
2959
2960         depotBlockOffset += sizeof(ULONG);
2961       }
2962     }
2963
2964     depotIndex++;
2965     depotBlockOffset = 0;
2966   }
2967
2968   /*
2969    * make sure that the block physically exists before using it
2970    */
2971   neededSize.QuadPart = StorageImpl_GetBigBlockOffset(This, freeBlock)+This->bigBlockSize;
2972   BIGBLOCKFILE_Expand(This->bigBlockFile, neededSize);
2973
2974   This->prevFreeBlock = freeBlock;
2975
2976   return freeBlock;
2977 }
2978
2979 /******************************************************************************
2980  *      Storage32Impl_AddBlockDepot
2981  *
2982  * This will create a depot block, essentially it is a block initialized
2983  * to BLOCK_UNUSEDs.
2984  */
2985 static void Storage32Impl_AddBlockDepot(StorageImpl* This, ULONG blockIndex)
2986 {
2987   BYTE blockBuffer[MAX_BIG_BLOCK_SIZE];
2988
2989   /*
2990    * Initialize blocks as free
2991    */
2992   memset(blockBuffer, BLOCK_UNUSED, This->bigBlockSize);
2993   StorageImpl_WriteBigBlock(This, blockIndex, blockBuffer);
2994 }
2995
2996 /******************************************************************************
2997  *      Storage32Impl_GetExtDepotBlock
2998  *
2999  * Returns the index of the block that corresponds to the specified depot
3000  * index. This method is only for depot indexes equal or greater than
3001  * COUNT_BBDEPOTINHEADER.
3002  */
3003 static ULONG Storage32Impl_GetExtDepotBlock(StorageImpl* This, ULONG depotIndex)
3004 {
3005   ULONG depotBlocksPerExtBlock = (This->bigBlockSize / sizeof(ULONG)) - 1;
3006   ULONG numExtBlocks           = depotIndex - COUNT_BBDEPOTINHEADER;
3007   ULONG extBlockCount          = numExtBlocks / depotBlocksPerExtBlock;
3008   ULONG extBlockOffset         = numExtBlocks % depotBlocksPerExtBlock;
3009   ULONG blockIndex             = BLOCK_UNUSED;
3010   ULONG extBlockIndex          = This->extBigBlockDepotStart;
3011
3012   assert(depotIndex >= COUNT_BBDEPOTINHEADER);
3013
3014   if (This->extBigBlockDepotStart == BLOCK_END_OF_CHAIN)
3015     return BLOCK_UNUSED;
3016
3017   while (extBlockCount > 0)
3018   {
3019     extBlockIndex = Storage32Impl_GetNextExtendedBlock(This, extBlockIndex);
3020     extBlockCount--;
3021   }
3022
3023   if (extBlockIndex != BLOCK_UNUSED)
3024     StorageImpl_ReadDWordFromBigBlock(This, extBlockIndex,
3025                         extBlockOffset * sizeof(ULONG), &blockIndex);
3026
3027   return blockIndex;
3028 }
3029
3030 /******************************************************************************
3031  *      Storage32Impl_SetExtDepotBlock
3032  *
3033  * Associates the specified block index to the specified depot index.
3034  * This method is only for depot indexes equal or greater than
3035  * COUNT_BBDEPOTINHEADER.
3036  */
3037 static void Storage32Impl_SetExtDepotBlock(StorageImpl* This, ULONG depotIndex, ULONG blockIndex)
3038 {
3039   ULONG depotBlocksPerExtBlock = (This->bigBlockSize / sizeof(ULONG)) - 1;
3040   ULONG numExtBlocks           = depotIndex - COUNT_BBDEPOTINHEADER;
3041   ULONG extBlockCount          = numExtBlocks / depotBlocksPerExtBlock;
3042   ULONG extBlockOffset         = numExtBlocks % depotBlocksPerExtBlock;
3043   ULONG extBlockIndex          = This->extBigBlockDepotStart;
3044
3045   assert(depotIndex >= COUNT_BBDEPOTINHEADER);
3046
3047   while (extBlockCount > 0)
3048   {
3049     extBlockIndex = Storage32Impl_GetNextExtendedBlock(This, extBlockIndex);
3050     extBlockCount--;
3051   }
3052
3053   if (extBlockIndex != BLOCK_UNUSED)
3054   {
3055     StorageImpl_WriteDWordToBigBlock(This, extBlockIndex,
3056                         extBlockOffset * sizeof(ULONG),
3057                         blockIndex);
3058   }
3059 }
3060
3061 /******************************************************************************
3062  *      Storage32Impl_AddExtBlockDepot
3063  *
3064  * Creates an extended depot block.
3065  */
3066 static ULONG Storage32Impl_AddExtBlockDepot(StorageImpl* This)
3067 {
3068   ULONG numExtBlocks           = This->extBigBlockDepotCount;
3069   ULONG nextExtBlock           = This->extBigBlockDepotStart;
3070   BYTE  depotBuffer[MAX_BIG_BLOCK_SIZE];
3071   ULONG index                  = BLOCK_UNUSED;
3072   ULONG nextBlockOffset        = This->bigBlockSize - sizeof(ULONG);
3073   ULONG blocksPerDepotBlock    = This->bigBlockSize / sizeof(ULONG);
3074   ULONG depotBlocksPerExtBlock = blocksPerDepotBlock - 1;
3075
3076   index = (COUNT_BBDEPOTINHEADER + (numExtBlocks * depotBlocksPerExtBlock)) *
3077           blocksPerDepotBlock;
3078
3079   if ((numExtBlocks == 0) && (nextExtBlock == BLOCK_END_OF_CHAIN))
3080   {
3081     /*
3082      * The first extended block.
3083      */
3084     This->extBigBlockDepotStart = index;
3085   }
3086   else
3087   {
3088     unsigned int i;
3089     /*
3090      * Follow the chain to the last one.
3091      */
3092     for (i = 0; i < (numExtBlocks - 1); i++)
3093     {
3094       nextExtBlock = Storage32Impl_GetNextExtendedBlock(This, nextExtBlock);
3095     }
3096
3097     /*
3098      * Add the new extended block to the chain.
3099      */
3100     StorageImpl_WriteDWordToBigBlock(This, nextExtBlock, nextBlockOffset,
3101                                      index);
3102   }
3103
3104   /*
3105    * Initialize this block.
3106    */
3107   memset(depotBuffer, BLOCK_UNUSED, This->bigBlockSize);
3108   StorageImpl_WriteBigBlock(This, index, depotBuffer);
3109
3110   return index;
3111 }
3112
3113 /******************************************************************************
3114  *      Storage32Impl_FreeBigBlock
3115  *
3116  * This method will flag the specified block as free in the big block depot.
3117  */
3118 static void StorageImpl_FreeBigBlock(
3119   StorageImpl* This,
3120   ULONG          blockIndex)
3121 {
3122   StorageImpl_SetNextBlockInChain(This, blockIndex, BLOCK_UNUSED);
3123
3124   if (blockIndex < This->prevFreeBlock)
3125     This->prevFreeBlock = blockIndex;
3126 }
3127
3128 /************************************************************************
3129  * Storage32Impl_GetNextBlockInChain
3130  *
3131  * This method will retrieve the block index of the next big block in
3132  * in the chain.
3133  *
3134  * Params:  This       - Pointer to the Storage object.
3135  *          blockIndex - Index of the block to retrieve the chain
3136  *                       for.
3137  *          nextBlockIndex - receives the return value.
3138  *
3139  * Returns: This method returns the index of the next block in the chain.
3140  *          It will return the constants:
3141  *              BLOCK_SPECIAL - If the block given was not part of a
3142  *                              chain.
3143  *              BLOCK_END_OF_CHAIN - If the block given was the last in
3144  *                                   a chain.
3145  *              BLOCK_UNUSED - If the block given was not past of a chain
3146  *                             and is available.
3147  *              BLOCK_EXTBBDEPOT - This block is part of the extended
3148  *                                 big block depot.
3149  *
3150  * See Windows documentation for more details on IStorage methods.
3151  */
3152 static HRESULT StorageImpl_GetNextBlockInChain(
3153   StorageImpl* This,
3154   ULONG        blockIndex,
3155   ULONG*       nextBlockIndex)
3156 {
3157   ULONG offsetInDepot    = blockIndex * sizeof (ULONG);
3158   ULONG depotBlockCount  = offsetInDepot / This->bigBlockSize;
3159   ULONG depotBlockOffset = offsetInDepot % This->bigBlockSize;
3160   BYTE depotBuffer[MAX_BIG_BLOCK_SIZE];
3161   BOOL success;
3162   ULONG depotBlockIndexPos;
3163   int index, num_blocks;
3164
3165   *nextBlockIndex   = BLOCK_SPECIAL;
3166
3167   if(depotBlockCount >= This->bigBlockDepotCount)
3168   {
3169     WARN("depotBlockCount %d, bigBlockDepotCount %d\n", depotBlockCount,
3170          This->bigBlockDepotCount);
3171     return STG_E_READFAULT;
3172   }
3173
3174   /*
3175    * Cache the currently accessed depot block.
3176    */
3177   if (depotBlockCount != This->indexBlockDepotCached)
3178   {
3179     This->indexBlockDepotCached = depotBlockCount;
3180
3181     if (depotBlockCount < COUNT_BBDEPOTINHEADER)
3182     {
3183       depotBlockIndexPos = This->bigBlockDepotStart[depotBlockCount];
3184     }
3185     else
3186     {
3187       /*
3188        * We have to look in the extended depot.
3189        */
3190       depotBlockIndexPos = Storage32Impl_GetExtDepotBlock(This, depotBlockCount);
3191     }
3192
3193     success = StorageImpl_ReadBigBlock(This, depotBlockIndexPos, depotBuffer);
3194
3195     if (!success)
3196       return STG_E_READFAULT;
3197
3198     num_blocks = This->bigBlockSize / 4;
3199
3200     for (index = 0; index < num_blocks; index++)
3201     {
3202       StorageUtl_ReadDWord(depotBuffer, index*sizeof(ULONG), nextBlockIndex);
3203       This->blockDepotCached[index] = *nextBlockIndex;
3204     }
3205   }
3206
3207   *nextBlockIndex = This->blockDepotCached[depotBlockOffset/sizeof(ULONG)];
3208
3209   return S_OK;
3210 }
3211
3212 /******************************************************************************
3213  *      Storage32Impl_GetNextExtendedBlock
3214  *
3215  * Given an extended block this method will return the next extended block.
3216  *
3217  * NOTES:
3218  * The last ULONG of an extended block is the block index of the next
3219  * extended block. Extended blocks are marked as BLOCK_EXTBBDEPOT in the
3220  * depot.
3221  *
3222  * Return values:
3223  *    - The index of the next extended block
3224  *    - BLOCK_UNUSED: there is no next extended block.
3225  *    - Any other return values denotes failure.
3226  */
3227 static ULONG Storage32Impl_GetNextExtendedBlock(StorageImpl* This, ULONG blockIndex)
3228 {
3229   ULONG nextBlockIndex   = BLOCK_SPECIAL;
3230   ULONG depotBlockOffset = This->bigBlockSize - sizeof(ULONG);
3231
3232   StorageImpl_ReadDWordFromBigBlock(This, blockIndex, depotBlockOffset,
3233                         &nextBlockIndex);
3234
3235   return nextBlockIndex;
3236 }
3237
3238 /******************************************************************************
3239  *      Storage32Impl_SetNextBlockInChain
3240  *
3241  * This method will write the index of the specified block's next block
3242  * in the big block depot.
3243  *
3244  * For example: to create the chain 3 -> 1 -> 7 -> End of Chain
3245  *              do the following
3246  *
3247  * Storage32Impl_SetNextBlockInChain(This, 3, 1);
3248  * Storage32Impl_SetNextBlockInChain(This, 1, 7);
3249  * Storage32Impl_SetNextBlockInChain(This, 7, BLOCK_END_OF_CHAIN);
3250  *
3251  */
3252 static void StorageImpl_SetNextBlockInChain(
3253           StorageImpl* This,
3254           ULONG          blockIndex,
3255           ULONG          nextBlock)
3256 {
3257   ULONG offsetInDepot    = blockIndex * sizeof (ULONG);
3258   ULONG depotBlockCount  = offsetInDepot / This->bigBlockSize;
3259   ULONG depotBlockOffset = offsetInDepot % This->bigBlockSize;
3260   ULONG depotBlockIndexPos;
3261
3262   assert(depotBlockCount < This->bigBlockDepotCount);
3263   assert(blockIndex != nextBlock);
3264
3265   if (depotBlockCount < COUNT_BBDEPOTINHEADER)
3266   {
3267     depotBlockIndexPos = This->bigBlockDepotStart[depotBlockCount];
3268   }
3269   else
3270   {
3271     /*
3272      * We have to look in the extended depot.
3273      */
3274     depotBlockIndexPos = Storage32Impl_GetExtDepotBlock(This, depotBlockCount);
3275   }
3276
3277   StorageImpl_WriteDWordToBigBlock(This, depotBlockIndexPos, depotBlockOffset,
3278                         nextBlock);
3279   /*
3280    * Update the cached block depot, if necessary.
3281    */
3282   if (depotBlockCount == This->indexBlockDepotCached)
3283   {
3284     This->blockDepotCached[depotBlockOffset/sizeof(ULONG)] = nextBlock;
3285   }
3286 }
3287
3288 /******************************************************************************
3289  *      Storage32Impl_LoadFileHeader
3290  *
3291  * This method will read in the file header
3292  */
3293 static HRESULT StorageImpl_LoadFileHeader(
3294           StorageImpl* This)
3295 {
3296   HRESULT hr;
3297   BYTE    headerBigBlock[HEADER_SIZE];
3298   int     index;
3299   ULARGE_INTEGER offset;
3300   DWORD bytes_read;
3301
3302   TRACE("\n");
3303   /*
3304    * Get a pointer to the big block of data containing the header.
3305    */
3306   offset.u.HighPart = 0;
3307   offset.u.LowPart = 0;
3308   hr = StorageImpl_ReadAt(This, offset, headerBigBlock, HEADER_SIZE, &bytes_read);
3309   if (SUCCEEDED(hr) && bytes_read != HEADER_SIZE)
3310     hr = STG_E_FILENOTFOUND;
3311
3312   /*
3313    * Extract the information from the header.
3314    */
3315   if (SUCCEEDED(hr))
3316   {
3317     /*
3318      * Check for the "magic number" signature and return an error if it is not
3319      * found.
3320      */
3321     if (memcmp(headerBigBlock, STORAGE_oldmagic, sizeof(STORAGE_oldmagic))==0)
3322     {
3323       return STG_E_OLDFORMAT;
3324     }
3325
3326     if (memcmp(headerBigBlock, STORAGE_magic, sizeof(STORAGE_magic))!=0)
3327     {
3328       return STG_E_INVALIDHEADER;
3329     }
3330
3331     StorageUtl_ReadWord(
3332       headerBigBlock,
3333       OFFSET_BIGBLOCKSIZEBITS,
3334       &This->bigBlockSizeBits);
3335
3336     StorageUtl_ReadWord(
3337       headerBigBlock,
3338       OFFSET_SMALLBLOCKSIZEBITS,
3339       &This->smallBlockSizeBits);
3340
3341     StorageUtl_ReadDWord(
3342       headerBigBlock,
3343       OFFSET_BBDEPOTCOUNT,
3344       &This->bigBlockDepotCount);
3345
3346     StorageUtl_ReadDWord(
3347       headerBigBlock,
3348       OFFSET_ROOTSTARTBLOCK,
3349       &This->rootStartBlock);
3350
3351     StorageUtl_ReadDWord(
3352       headerBigBlock,
3353       OFFSET_SBDEPOTSTART,
3354       &This->smallBlockDepotStart);
3355
3356     StorageUtl_ReadDWord(
3357       headerBigBlock,
3358       OFFSET_EXTBBDEPOTSTART,
3359       &This->extBigBlockDepotStart);
3360
3361     StorageUtl_ReadDWord(
3362       headerBigBlock,
3363       OFFSET_EXTBBDEPOTCOUNT,
3364       &This->extBigBlockDepotCount);
3365
3366     for (index = 0; index < COUNT_BBDEPOTINHEADER; index ++)
3367     {
3368       StorageUtl_ReadDWord(
3369         headerBigBlock,
3370         OFFSET_BBDEPOTSTART + (sizeof(ULONG)*index),
3371         &(This->bigBlockDepotStart[index]));
3372     }
3373
3374     /*
3375      * Make the bitwise arithmetic to get the size of the blocks in bytes.
3376      */
3377     This->bigBlockSize   = 0x000000001 << (DWORD)This->bigBlockSizeBits;
3378     This->smallBlockSize = 0x000000001 << (DWORD)This->smallBlockSizeBits;
3379
3380     /*
3381      * Right now, the code is making some assumptions about the size of the
3382      * blocks, just make sure they are what we're expecting.
3383      */
3384     if ((This->bigBlockSize != MIN_BIG_BLOCK_SIZE && This->bigBlockSize != MAX_BIG_BLOCK_SIZE) ||
3385         This->smallBlockSize != DEF_SMALL_BLOCK_SIZE)
3386     {
3387         WARN("Broken OLE storage file\n");
3388         hr = STG_E_INVALIDHEADER;
3389     }
3390     else
3391         hr = S_OK;
3392   }
3393
3394   return hr;
3395 }
3396
3397 /******************************************************************************
3398  *      Storage32Impl_SaveFileHeader
3399  *
3400  * This method will save to the file the header
3401  */
3402 static void StorageImpl_SaveFileHeader(
3403           StorageImpl* This)
3404 {
3405   BYTE   headerBigBlock[HEADER_SIZE];
3406   int    index;
3407   HRESULT hr;
3408   ULARGE_INTEGER offset;
3409   DWORD bytes_read, bytes_written;
3410
3411   /*
3412    * Get a pointer to the big block of data containing the header.
3413    */
3414   offset.u.HighPart = 0;
3415   offset.u.LowPart = 0;
3416   hr = StorageImpl_ReadAt(This, offset, headerBigBlock, HEADER_SIZE, &bytes_read);
3417   if (SUCCEEDED(hr) && bytes_read != HEADER_SIZE)
3418     hr = STG_E_FILENOTFOUND;
3419
3420   /*
3421    * If the block read failed, the file is probably new.
3422    */
3423   if (FAILED(hr))
3424   {
3425     /*
3426      * Initialize for all unknown fields.
3427      */
3428     memset(headerBigBlock, 0, HEADER_SIZE);
3429
3430     /*
3431      * Initialize the magic number.
3432      */
3433     memcpy(headerBigBlock, STORAGE_magic, sizeof(STORAGE_magic));
3434
3435     /*
3436      * And a bunch of things we don't know what they mean
3437      */
3438     StorageUtl_WriteWord(headerBigBlock,  0x18, 0x3b);
3439     StorageUtl_WriteWord(headerBigBlock,  0x1a, 0x3);
3440     StorageUtl_WriteWord(headerBigBlock,  0x1c, (WORD)-2);
3441     StorageUtl_WriteDWord(headerBigBlock, 0x38, (DWORD)0x1000);
3442   }
3443
3444   /*
3445    * Write the information to the header.
3446    */
3447   StorageUtl_WriteWord(
3448     headerBigBlock,
3449     OFFSET_BIGBLOCKSIZEBITS,
3450     This->bigBlockSizeBits);
3451
3452   StorageUtl_WriteWord(
3453     headerBigBlock,
3454     OFFSET_SMALLBLOCKSIZEBITS,
3455     This->smallBlockSizeBits);
3456
3457   StorageUtl_WriteDWord(
3458     headerBigBlock,
3459     OFFSET_BBDEPOTCOUNT,
3460     This->bigBlockDepotCount);
3461
3462   StorageUtl_WriteDWord(
3463     headerBigBlock,
3464     OFFSET_ROOTSTARTBLOCK,
3465     This->rootStartBlock);
3466
3467   StorageUtl_WriteDWord(
3468     headerBigBlock,
3469     OFFSET_SBDEPOTSTART,
3470     This->smallBlockDepotStart);
3471
3472   StorageUtl_WriteDWord(
3473     headerBigBlock,
3474     OFFSET_SBDEPOTCOUNT,
3475     This->smallBlockDepotChain ?
3476      BlockChainStream_GetCount(This->smallBlockDepotChain) : 0);
3477
3478   StorageUtl_WriteDWord(
3479     headerBigBlock,
3480     OFFSET_EXTBBDEPOTSTART,
3481     This->extBigBlockDepotStart);
3482
3483   StorageUtl_WriteDWord(
3484     headerBigBlock,
3485     OFFSET_EXTBBDEPOTCOUNT,
3486     This->extBigBlockDepotCount);
3487
3488   for (index = 0; index < COUNT_BBDEPOTINHEADER; index ++)
3489   {
3490     StorageUtl_WriteDWord(
3491       headerBigBlock,
3492       OFFSET_BBDEPOTSTART + (sizeof(ULONG)*index),
3493       (This->bigBlockDepotStart[index]));
3494   }
3495
3496   /*
3497    * Write the big block back to the file.
3498    */
3499   StorageImpl_WriteAt(This, offset, headerBigBlock, HEADER_SIZE, &bytes_written);
3500 }
3501
3502 /******************************************************************************
3503  *      StorageImpl_ReadRawDirEntry
3504  *
3505  * This method will read the raw data from a directory entry in the file.
3506  *
3507  * buffer must be RAW_DIRENTRY_SIZE bytes long.
3508  */
3509 HRESULT StorageImpl_ReadRawDirEntry(StorageImpl *This, ULONG index, BYTE *buffer)
3510 {
3511   ULARGE_INTEGER offset;
3512   HRESULT hr;
3513   ULONG bytesRead;
3514
3515   offset.u.HighPart = 0;
3516   offset.u.LowPart  = index * RAW_DIRENTRY_SIZE;
3517
3518   hr = BlockChainStream_ReadAt(
3519                     This->rootBlockChain,
3520                     offset,
3521                     RAW_DIRENTRY_SIZE,
3522                     buffer,
3523                     &bytesRead);
3524
3525   return hr;
3526 }
3527
3528 /******************************************************************************
3529  *      StorageImpl_WriteRawDirEntry
3530  *
3531  * This method will write the raw data from a directory entry in the file.
3532  *
3533  * buffer must be RAW_DIRENTRY_SIZE bytes long.
3534  */
3535 HRESULT StorageImpl_WriteRawDirEntry(StorageImpl *This, ULONG index, const BYTE *buffer)
3536 {
3537   ULARGE_INTEGER offset;
3538   HRESULT hr;
3539   ULONG bytesRead;
3540
3541   offset.u.HighPart = 0;
3542   offset.u.LowPart  = index * RAW_DIRENTRY_SIZE;
3543
3544   hr = BlockChainStream_WriteAt(
3545                     This->rootBlockChain,
3546                     offset,
3547                     RAW_DIRENTRY_SIZE,
3548                     buffer,
3549                     &bytesRead);
3550
3551   return hr;
3552 }
3553
3554 /******************************************************************************
3555  *      UpdateRawDirEntry
3556  *
3557  * Update raw directory entry data from the fields in newData.
3558  *
3559  * buffer must be RAW_DIRENTRY_SIZE bytes long.
3560  */
3561 void UpdateRawDirEntry(BYTE *buffer, const DirEntry *newData)
3562 {
3563   memset(buffer, 0, RAW_DIRENTRY_SIZE);
3564
3565   memcpy(
3566     buffer + OFFSET_PS_NAME,
3567     newData->name,
3568     DIRENTRY_NAME_BUFFER_LEN );
3569
3570   memcpy(buffer + OFFSET_PS_STGTYPE, &newData->stgType, 1);
3571
3572   StorageUtl_WriteWord(
3573     buffer,
3574       OFFSET_PS_NAMELENGTH,
3575       newData->sizeOfNameString);
3576
3577   StorageUtl_WriteDWord(
3578     buffer,
3579       OFFSET_PS_LEFTCHILD,
3580       newData->leftChild);
3581
3582   StorageUtl_WriteDWord(
3583     buffer,
3584       OFFSET_PS_RIGHTCHILD,
3585       newData->rightChild);
3586
3587   StorageUtl_WriteDWord(
3588     buffer,
3589       OFFSET_PS_DIRROOT,
3590       newData->dirRootEntry);
3591
3592   StorageUtl_WriteGUID(
3593     buffer,
3594       OFFSET_PS_GUID,
3595       &newData->clsid);
3596
3597   StorageUtl_WriteDWord(
3598     buffer,
3599       OFFSET_PS_CTIMELOW,
3600       newData->ctime.dwLowDateTime);
3601
3602   StorageUtl_WriteDWord(
3603     buffer,
3604       OFFSET_PS_CTIMEHIGH,
3605       newData->ctime.dwHighDateTime);
3606
3607   StorageUtl_WriteDWord(
3608     buffer,
3609       OFFSET_PS_MTIMELOW,
3610       newData->mtime.dwLowDateTime);
3611
3612   StorageUtl_WriteDWord(
3613     buffer,
3614       OFFSET_PS_MTIMEHIGH,
3615       newData->ctime.dwHighDateTime);
3616
3617   StorageUtl_WriteDWord(
3618     buffer,
3619       OFFSET_PS_STARTBLOCK,
3620       newData->startingBlock);
3621
3622   StorageUtl_WriteDWord(
3623     buffer,
3624       OFFSET_PS_SIZE,
3625       newData->size.u.LowPart);
3626 }
3627
3628 /******************************************************************************
3629  *      Storage32Impl_ReadDirEntry
3630  *
3631  * This method will read the specified directory entry.
3632  */
3633 HRESULT StorageImpl_ReadDirEntry(
3634   StorageImpl* This,
3635   DirRef         index,
3636   DirEntry*      buffer)
3637 {
3638   BYTE           currentEntry[RAW_DIRENTRY_SIZE];
3639   HRESULT        readRes;
3640
3641   readRes = StorageImpl_ReadRawDirEntry(This, index, currentEntry);
3642
3643   if (SUCCEEDED(readRes))
3644   {
3645     memset(buffer->name, 0, sizeof(buffer->name));
3646     memcpy(
3647       buffer->name,
3648       (WCHAR *)currentEntry+OFFSET_PS_NAME,
3649       DIRENTRY_NAME_BUFFER_LEN );
3650     TRACE("storage name: %s\n", debugstr_w(buffer->name));
3651
3652     memcpy(&buffer->stgType, currentEntry + OFFSET_PS_STGTYPE, 1);
3653
3654     StorageUtl_ReadWord(
3655       currentEntry,
3656       OFFSET_PS_NAMELENGTH,
3657       &buffer->sizeOfNameString);
3658
3659     StorageUtl_ReadDWord(
3660       currentEntry,
3661       OFFSET_PS_LEFTCHILD,
3662       &buffer->leftChild);
3663
3664     StorageUtl_ReadDWord(
3665       currentEntry,
3666       OFFSET_PS_RIGHTCHILD,
3667       &buffer->rightChild);
3668
3669     StorageUtl_ReadDWord(
3670       currentEntry,
3671       OFFSET_PS_DIRROOT,
3672       &buffer->dirRootEntry);
3673
3674     StorageUtl_ReadGUID(
3675       currentEntry,
3676       OFFSET_PS_GUID,
3677       &buffer->clsid);
3678
3679     StorageUtl_ReadDWord(
3680       currentEntry,
3681       OFFSET_PS_CTIMELOW,
3682       &buffer->ctime.dwLowDateTime);
3683
3684     StorageUtl_ReadDWord(
3685       currentEntry,
3686       OFFSET_PS_CTIMEHIGH,
3687       &buffer->ctime.dwHighDateTime);
3688
3689     StorageUtl_ReadDWord(
3690       currentEntry,
3691       OFFSET_PS_MTIMELOW,
3692       &buffer->mtime.dwLowDateTime);
3693
3694     StorageUtl_ReadDWord(
3695       currentEntry,
3696       OFFSET_PS_MTIMEHIGH,
3697       &buffer->mtime.dwHighDateTime);
3698
3699     StorageUtl_ReadDWord(
3700       currentEntry,
3701       OFFSET_PS_STARTBLOCK,
3702       &buffer->startingBlock);
3703
3704     StorageUtl_ReadDWord(
3705       currentEntry,
3706       OFFSET_PS_SIZE,
3707       &buffer->size.u.LowPart);
3708
3709     buffer->size.u.HighPart = 0;
3710   }
3711
3712   return readRes;
3713 }
3714
3715 /*********************************************************************
3716  * Write the specified directory entry to the file
3717  */
3718 HRESULT StorageImpl_WriteDirEntry(
3719   StorageImpl*          This,
3720   DirRef                index,
3721   const DirEntry*       buffer)
3722 {
3723   BYTE           currentEntry[RAW_DIRENTRY_SIZE];
3724   HRESULT        writeRes;
3725
3726   UpdateRawDirEntry(currentEntry, buffer);
3727
3728   writeRes = StorageImpl_WriteRawDirEntry(This, index, currentEntry);
3729   return writeRes;
3730 }
3731
3732 static BOOL StorageImpl_ReadBigBlock(
3733   StorageImpl* This,
3734   ULONG          blockIndex,
3735   void*          buffer)
3736 {
3737   ULARGE_INTEGER ulOffset;
3738   DWORD  read;
3739
3740   ulOffset.u.HighPart = 0;
3741   ulOffset.u.LowPart = StorageImpl_GetBigBlockOffset(This, blockIndex);
3742
3743   StorageImpl_ReadAt(This, ulOffset, buffer, This->bigBlockSize, &read);
3744   return (read == This->bigBlockSize);
3745 }
3746
3747 static BOOL StorageImpl_ReadDWordFromBigBlock(
3748   StorageImpl*  This,
3749   ULONG         blockIndex,
3750   ULONG         offset,
3751   DWORD*        value)
3752 {
3753   ULARGE_INTEGER ulOffset;
3754   DWORD  read;
3755   DWORD  tmp;
3756
3757   ulOffset.u.HighPart = 0;
3758   ulOffset.u.LowPart = StorageImpl_GetBigBlockOffset(This, blockIndex);
3759   ulOffset.u.LowPart += offset;
3760
3761   StorageImpl_ReadAt(This, ulOffset, &tmp, sizeof(DWORD), &read);
3762   *value = lendian32toh(tmp);
3763   return (read == sizeof(DWORD));
3764 }
3765
3766 static BOOL StorageImpl_WriteBigBlock(
3767   StorageImpl*  This,
3768   ULONG         blockIndex,
3769   const void*   buffer)
3770 {
3771   ULARGE_INTEGER ulOffset;
3772   DWORD  wrote;
3773
3774   ulOffset.u.HighPart = 0;
3775   ulOffset.u.LowPart = StorageImpl_GetBigBlockOffset(This, blockIndex);
3776
3777   StorageImpl_WriteAt(This, ulOffset, buffer, This->bigBlockSize, &wrote);
3778   return (wrote == This->bigBlockSize);
3779 }
3780
3781 static BOOL StorageImpl_WriteDWordToBigBlock(
3782   StorageImpl* This,
3783   ULONG         blockIndex,
3784   ULONG         offset,
3785   DWORD         value)
3786 {
3787   ULARGE_INTEGER ulOffset;
3788   DWORD  wrote;
3789
3790   ulOffset.u.HighPart = 0;
3791   ulOffset.u.LowPart = StorageImpl_GetBigBlockOffset(This, blockIndex);
3792   ulOffset.u.LowPart += offset;
3793
3794   value = htole32(value);
3795   StorageImpl_WriteAt(This, ulOffset, &value, sizeof(DWORD), &wrote);
3796   return (wrote == sizeof(DWORD));
3797 }
3798
3799 /******************************************************************************
3800  *              Storage32Impl_SmallBlocksToBigBlocks
3801  *
3802  * This method will convert a small block chain to a big block chain.
3803  * The small block chain will be destroyed.
3804  */
3805 BlockChainStream* Storage32Impl_SmallBlocksToBigBlocks(
3806                       StorageImpl* This,
3807                       SmallBlockChainStream** ppsbChain)
3808 {
3809   ULONG bbHeadOfChain = BLOCK_END_OF_CHAIN;
3810   ULARGE_INTEGER size, offset;
3811   ULONG cbRead, cbWritten;
3812   ULARGE_INTEGER cbTotalRead;
3813   DirRef streamEntryRef;
3814   HRESULT resWrite = S_OK;
3815   HRESULT resRead;
3816   DirEntry streamEntry;
3817   BYTE *buffer;
3818   BlockChainStream *bbTempChain = NULL;
3819   BlockChainStream *bigBlockChain = NULL;
3820
3821   /*
3822    * Create a temporary big block chain that doesn't have
3823    * an associated directory entry. This temporary chain will be
3824    * used to copy data from small blocks to big blocks.
3825    */
3826   bbTempChain = BlockChainStream_Construct(This,
3827                                            &bbHeadOfChain,
3828                                            DIRENTRY_NULL);
3829   if(!bbTempChain) return NULL;
3830   /*
3831    * Grow the big block chain.
3832    */
3833   size = SmallBlockChainStream_GetSize(*ppsbChain);
3834   BlockChainStream_SetSize(bbTempChain, size);
3835
3836   /*
3837    * Copy the contents of the small block chain to the big block chain
3838    * by small block size increments.
3839    */
3840   offset.u.LowPart = 0;
3841   offset.u.HighPart = 0;
3842   cbTotalRead.QuadPart = 0;
3843
3844   buffer = HeapAlloc(GetProcessHeap(),0,DEF_SMALL_BLOCK_SIZE);
3845   do
3846   {
3847     resRead = SmallBlockChainStream_ReadAt(*ppsbChain,
3848                                            offset,
3849                                            min(This->smallBlockSize, size.u.LowPart - offset.u.LowPart),
3850                                            buffer,
3851                                            &cbRead);
3852     if (FAILED(resRead))
3853         break;
3854
3855     if (cbRead > 0)
3856     {
3857         cbTotalRead.QuadPart += cbRead;
3858
3859         resWrite = BlockChainStream_WriteAt(bbTempChain,
3860                                             offset,
3861                                             cbRead,
3862                                             buffer,
3863                                             &cbWritten);
3864
3865         if (FAILED(resWrite))
3866             break;
3867
3868         offset.u.LowPart += cbRead;
3869     }
3870   } while (cbTotalRead.QuadPart < size.QuadPart);
3871   HeapFree(GetProcessHeap(),0,buffer);
3872
3873   size.u.HighPart = 0;
3874   size.u.LowPart  = 0;
3875
3876   if (FAILED(resRead) || FAILED(resWrite))
3877   {
3878     ERR("conversion failed: resRead = 0x%08x, resWrite = 0x%08x\n", resRead, resWrite);
3879     BlockChainStream_SetSize(bbTempChain, size);
3880     BlockChainStream_Destroy(bbTempChain);
3881     return NULL;
3882   }
3883
3884   /*
3885    * Destroy the small block chain.
3886    */
3887   streamEntryRef = (*ppsbChain)->ownerDirEntry;
3888   SmallBlockChainStream_SetSize(*ppsbChain, size);
3889   SmallBlockChainStream_Destroy(*ppsbChain);
3890   *ppsbChain = 0;
3891
3892   /*
3893    * Change the directory entry. This chain is now a big block chain
3894    * and it doesn't reside in the small blocks chain anymore.
3895    */
3896   StorageImpl_ReadDirEntry(This, streamEntryRef, &streamEntry);
3897
3898   streamEntry.startingBlock = bbHeadOfChain;
3899
3900   StorageImpl_WriteDirEntry(This, streamEntryRef, &streamEntry);
3901
3902   /*
3903    * Destroy the temporary entryless big block chain.
3904    * Create a new big block chain associated with this entry.
3905    */
3906   BlockChainStream_Destroy(bbTempChain);
3907   bigBlockChain = BlockChainStream_Construct(This,
3908                                              NULL,
3909                                              streamEntryRef);
3910
3911   return bigBlockChain;
3912 }
3913
3914 /******************************************************************************
3915  *              Storage32Impl_BigBlocksToSmallBlocks
3916  *
3917  * This method will convert a big block chain to a small block chain.
3918  * The big block chain will be destroyed on success.
3919  */
3920 SmallBlockChainStream* Storage32Impl_BigBlocksToSmallBlocks(
3921                            StorageImpl* This,
3922                            BlockChainStream** ppbbChain)
3923 {
3924     ULARGE_INTEGER size, offset, cbTotalRead;
3925     ULONG cbRead, cbWritten, sbHeadOfChain = BLOCK_END_OF_CHAIN;
3926     DirRef streamEntryRef;
3927     HRESULT resWrite = S_OK, resRead;
3928     DirEntry streamEntry;
3929     BYTE* buffer;
3930     SmallBlockChainStream* sbTempChain;
3931
3932     TRACE("%p %p\n", This, ppbbChain);
3933
3934     sbTempChain = SmallBlockChainStream_Construct(This, &sbHeadOfChain,
3935             DIRENTRY_NULL);
3936
3937     if(!sbTempChain)
3938         return NULL;
3939
3940     size = BlockChainStream_GetSize(*ppbbChain);
3941     SmallBlockChainStream_SetSize(sbTempChain, size);
3942
3943     offset.u.HighPart = 0;
3944     offset.u.LowPart = 0;
3945     cbTotalRead.QuadPart = 0;
3946     buffer = HeapAlloc(GetProcessHeap(), 0, This->bigBlockSize);
3947     do
3948     {
3949         resRead = BlockChainStream_ReadAt(*ppbbChain, offset,
3950                 min(This->bigBlockSize, size.u.LowPart - offset.u.LowPart),
3951                 buffer, &cbRead);
3952
3953         if(FAILED(resRead))
3954             break;
3955
3956         if(cbRead > 0)
3957         {
3958             cbTotalRead.QuadPart += cbRead;
3959
3960             resWrite = SmallBlockChainStream_WriteAt(sbTempChain, offset,
3961                     cbRead, buffer, &cbWritten);
3962
3963             if(FAILED(resWrite))
3964                 break;
3965
3966             offset.u.LowPart += cbRead;
3967         }
3968     }while(cbTotalRead.QuadPart < size.QuadPart);
3969     HeapFree(GetProcessHeap(), 0, buffer);
3970
3971     size.u.HighPart = 0;
3972     size.u.LowPart = 0;
3973
3974     if(FAILED(resRead) || FAILED(resWrite))
3975     {
3976         ERR("conversion failed: resRead = 0x%08x, resWrite = 0x%08x\n", resRead, resWrite);
3977         SmallBlockChainStream_SetSize(sbTempChain, size);
3978         SmallBlockChainStream_Destroy(sbTempChain);
3979         return NULL;
3980     }
3981
3982     /* destroy the original big block chain */
3983     streamEntryRef = (*ppbbChain)->ownerDirEntry;
3984     BlockChainStream_SetSize(*ppbbChain, size);
3985     BlockChainStream_Destroy(*ppbbChain);
3986     *ppbbChain = NULL;
3987
3988     StorageImpl_ReadDirEntry(This, streamEntryRef, &streamEntry);
3989     streamEntry.startingBlock = sbHeadOfChain;
3990     StorageImpl_WriteDirEntry(This, streamEntryRef, &streamEntry);
3991
3992     SmallBlockChainStream_Destroy(sbTempChain);
3993     return SmallBlockChainStream_Construct(This, NULL, streamEntryRef);
3994 }
3995
3996 static HRESULT CreateSnapshotFile(StorageBaseImpl* original, StorageBaseImpl **snapshot)
3997 {
3998   HRESULT hr;
3999   DirEntry parentData, snapshotData;
4000
4001   hr = StgCreateDocfile(NULL, STGM_READWRITE|STGM_SHARE_EXCLUSIVE|STGM_DELETEONRELEASE,
4002       0, (IStorage**)snapshot);
4003
4004   if (SUCCEEDED(hr))
4005   {
4006     hr = StorageBaseImpl_ReadDirEntry(original,
4007       original->storageDirEntry, &parentData);
4008
4009     if (SUCCEEDED(hr))
4010       hr = StorageBaseImpl_ReadDirEntry((*snapshot),
4011         (*snapshot)->storageDirEntry, &snapshotData);
4012
4013     if (SUCCEEDED(hr))
4014     {
4015       memcpy(snapshotData.name, parentData.name, sizeof(snapshotData.name));
4016       snapshotData.sizeOfNameString = parentData.sizeOfNameString;
4017       snapshotData.stgType = parentData.stgType;
4018       snapshotData.clsid = parentData.clsid;
4019       snapshotData.ctime = parentData.ctime;
4020       snapshotData.mtime = parentData.mtime;
4021       hr = StorageBaseImpl_WriteDirEntry((*snapshot),
4022         (*snapshot)->storageDirEntry, &snapshotData);
4023     }
4024
4025     if (SUCCEEDED(hr))
4026       hr = IStorage_CopyTo((IStorage*)original, 0, NULL, NULL,
4027           (IStorage*)(*snapshot));
4028
4029     if (FAILED(hr)) IStorage_Release((IStorage*)(*snapshot));
4030   }
4031
4032   return hr;
4033 }
4034
4035 static HRESULT WINAPI TransactedSnapshotImpl_Commit(
4036   IStorage*            iface,
4037   DWORD                  grfCommitFlags)  /* [in] */
4038 {
4039   TransactedSnapshotImpl* This = (TransactedSnapshotImpl*) iface;
4040   HRESULT hr;
4041   DirEntry data, tempStorageData, snapshotRootData;
4042   DirRef tempStorageEntry, oldDirRoot;
4043   StorageInternalImpl *tempStorage;
4044
4045   TRACE("(%p,%x)\n", iface, grfCommitFlags);
4046
4047   /* Cannot commit a read-only transacted storage */
4048   if ( STGM_ACCESS_MODE( This->base.openFlags ) == STGM_READ )
4049     return STG_E_ACCESSDENIED;
4050
4051   /* To prevent data loss, we create the new structure in the file before we
4052    * delete the old one, so that in case of errors the old data is intact. We
4053    * shouldn't do this if STGC_OVERWRITE is set, but that flag should only be
4054    * needed in the rare situation where we have just enough free disk space to
4055    * overwrite the existing data. */
4056
4057   /* Create an orphaned storage in the parent for the new directory structure. */
4058   memset(&data, 0, sizeof(data));
4059   data.name[0] = 'D';
4060   data.sizeOfNameString = 1;
4061   data.stgType = STGTY_STORAGE;
4062   data.leftChild = DIRENTRY_NULL;
4063   data.rightChild = DIRENTRY_NULL;
4064   data.dirRootEntry = DIRENTRY_NULL;
4065   hr = StorageBaseImpl_CreateDirEntry(This->transactedParent, &data, &tempStorageEntry);
4066
4067   if (FAILED(hr)) return hr;
4068
4069   tempStorage = StorageInternalImpl_Construct(This->transactedParent,
4070     STGM_READWRITE|STGM_SHARE_EXCLUSIVE, tempStorageEntry);
4071   if (tempStorage)
4072   {
4073     hr = IStorage_CopyTo((IStorage*)This->snapshot, 0, NULL, NULL,
4074         (IStorage*)tempStorage);
4075
4076     list_init(&tempStorage->ParentListEntry);
4077
4078     IStorage_Release((IStorage*) tempStorage);
4079   }
4080   else
4081     hr = E_OUTOFMEMORY;
4082
4083   if (FAILED(hr))
4084   {
4085     DestroyReachableEntries(This->transactedParent, tempStorageEntry);
4086     return hr;
4087   }
4088
4089   /* Update the storage to use the new data in one step. */
4090   hr = StorageBaseImpl_ReadDirEntry(This->transactedParent,
4091     This->transactedParent->storageDirEntry, &data);
4092
4093   if (SUCCEEDED(hr))
4094   {
4095     hr = StorageBaseImpl_ReadDirEntry(This->transactedParent,
4096       tempStorageEntry, &tempStorageData);
4097   }
4098
4099   if (SUCCEEDED(hr))
4100   {
4101     hr = StorageBaseImpl_ReadDirEntry(This->snapshot,
4102       This->snapshot->storageDirEntry, &snapshotRootData);
4103   }
4104
4105   if (SUCCEEDED(hr))
4106   {
4107     oldDirRoot = data.dirRootEntry;
4108     data.dirRootEntry = tempStorageData.dirRootEntry;
4109     data.clsid = snapshotRootData.clsid;
4110     data.ctime = snapshotRootData.ctime;
4111     data.mtime = snapshotRootData.mtime;
4112
4113     hr = StorageBaseImpl_WriteDirEntry(This->transactedParent,
4114       This->transactedParent->storageDirEntry, &data);
4115   }
4116
4117   if (SUCCEEDED(hr))
4118   {
4119     /* Destroy the old now-orphaned data. */
4120     DestroyReachableEntries(This->transactedParent, oldDirRoot);
4121     StorageBaseImpl_DestroyDirEntry(This->transactedParent, tempStorageEntry);
4122   }
4123   else
4124   {
4125     DestroyReachableEntries(This->transactedParent, tempStorageEntry);
4126   }
4127
4128   return hr;
4129 }
4130
4131 static HRESULT WINAPI TransactedSnapshotImpl_Revert(
4132   IStorage*            iface)
4133 {
4134   TransactedSnapshotImpl* This = (TransactedSnapshotImpl*) iface;
4135   StorageBaseImpl *newSnapshot;
4136   HRESULT hr;
4137
4138   TRACE("(%p)\n", iface);
4139
4140   /* Create a new copy of the parent data. */
4141   hr = CreateSnapshotFile(This->transactedParent, &newSnapshot);
4142   if (FAILED(hr)) return hr;
4143
4144   /* Destroy the open objects. */
4145   StorageBaseImpl_DeleteAll(&This->base);
4146
4147   /* Replace our current snapshot. */
4148   IStorage_Release((IStorage*)This->snapshot);
4149   This->snapshot = newSnapshot;
4150
4151   return S_OK;
4152 }
4153
4154 static void TransactedSnapshotImpl_Invalidate(StorageBaseImpl* This)
4155 {
4156   if (!This->reverted)
4157   {
4158     TRACE("Storage invalidated (stg=%p)\n", This);
4159
4160     This->reverted = 1;
4161
4162     StorageBaseImpl_DeleteAll(This);
4163   }
4164 }
4165
4166 static void TransactedSnapshotImpl_Destroy( StorageBaseImpl *iface)
4167 {
4168   TransactedSnapshotImpl* This = (TransactedSnapshotImpl*) iface;
4169
4170   TransactedSnapshotImpl_Invalidate(iface);
4171
4172   IStorage_Release((IStorage*)This->transactedParent);
4173
4174   IStorage_Release((IStorage*)This->snapshot);
4175
4176   HeapFree(GetProcessHeap(), 0, This);
4177 }
4178
4179 static HRESULT TransactedSnapshotImpl_CreateDirEntry(StorageBaseImpl *base,
4180   const DirEntry *newData, DirRef *index)
4181 {
4182   TransactedSnapshotImpl* This = (TransactedSnapshotImpl*) base;
4183
4184   return StorageBaseImpl_CreateDirEntry(This->snapshot,
4185     newData, index);
4186 }
4187
4188 static HRESULT TransactedSnapshotImpl_WriteDirEntry(StorageBaseImpl *base,
4189   DirRef index, const DirEntry *data)
4190 {
4191   TransactedSnapshotImpl* This = (TransactedSnapshotImpl*) base;
4192
4193   return StorageBaseImpl_WriteDirEntry(This->snapshot,
4194     index, data);
4195 }
4196
4197 static HRESULT TransactedSnapshotImpl_ReadDirEntry(StorageBaseImpl *base,
4198   DirRef index, DirEntry *data)
4199 {
4200   TransactedSnapshotImpl* This = (TransactedSnapshotImpl*) base;
4201
4202   return StorageBaseImpl_ReadDirEntry(This->snapshot,
4203     index, data);
4204 }
4205
4206 static HRESULT TransactedSnapshotImpl_DestroyDirEntry(StorageBaseImpl *base,
4207   DirRef index)
4208 {
4209   TransactedSnapshotImpl* This = (TransactedSnapshotImpl*) base;
4210
4211   return StorageBaseImpl_DestroyDirEntry(This->snapshot,
4212     index);
4213 }
4214
4215 static HRESULT TransactedSnapshotImpl_StreamReadAt(StorageBaseImpl *base,
4216   DirRef index, ULARGE_INTEGER offset, ULONG size, void *buffer, ULONG *bytesRead)
4217 {
4218   TransactedSnapshotImpl* This = (TransactedSnapshotImpl*) base;
4219
4220   return StorageBaseImpl_StreamReadAt(This->snapshot,
4221     index, offset, size, buffer, bytesRead);
4222 }
4223
4224 static HRESULT TransactedSnapshotImpl_StreamWriteAt(StorageBaseImpl *base,
4225   DirRef index, ULARGE_INTEGER offset, ULONG size, const void *buffer, ULONG *bytesWritten)
4226 {
4227   TransactedSnapshotImpl* This = (TransactedSnapshotImpl*) base;
4228
4229   return StorageBaseImpl_StreamWriteAt(This->snapshot,
4230     index, offset, size, buffer, bytesWritten);
4231 }
4232
4233 static HRESULT TransactedSnapshotImpl_StreamSetSize(StorageBaseImpl *base,
4234   DirRef index, ULARGE_INTEGER newsize)
4235 {
4236   TransactedSnapshotImpl* This = (TransactedSnapshotImpl*) base;
4237
4238   return StorageBaseImpl_StreamSetSize(This->snapshot,
4239     index, newsize);
4240 }
4241
4242 static const IStorageVtbl TransactedSnapshotImpl_Vtbl =
4243 {
4244     StorageBaseImpl_QueryInterface,
4245     StorageBaseImpl_AddRef,
4246     StorageBaseImpl_Release,
4247     StorageBaseImpl_CreateStream,
4248     StorageBaseImpl_OpenStream,
4249     StorageBaseImpl_CreateStorage,
4250     StorageBaseImpl_OpenStorage,
4251     StorageBaseImpl_CopyTo,
4252     StorageBaseImpl_MoveElementTo,
4253     TransactedSnapshotImpl_Commit,
4254     TransactedSnapshotImpl_Revert,
4255     StorageBaseImpl_EnumElements,
4256     StorageBaseImpl_DestroyElement,
4257     StorageBaseImpl_RenameElement,
4258     StorageBaseImpl_SetElementTimes,
4259     StorageBaseImpl_SetClass,
4260     StorageBaseImpl_SetStateBits,
4261     StorageBaseImpl_Stat
4262 };
4263
4264 static const StorageBaseImplVtbl TransactedSnapshotImpl_BaseVtbl =
4265 {
4266   TransactedSnapshotImpl_Destroy,
4267   TransactedSnapshotImpl_Invalidate,
4268   TransactedSnapshotImpl_CreateDirEntry,
4269   TransactedSnapshotImpl_WriteDirEntry,
4270   TransactedSnapshotImpl_ReadDirEntry,
4271   TransactedSnapshotImpl_DestroyDirEntry,
4272   TransactedSnapshotImpl_StreamReadAt,
4273   TransactedSnapshotImpl_StreamWriteAt,
4274   TransactedSnapshotImpl_StreamSetSize
4275 };
4276
4277 static HRESULT TransactedSnapshotImpl_Construct(StorageBaseImpl *parentStorage,
4278   TransactedSnapshotImpl** result)
4279 {
4280   HRESULT hr;
4281
4282   *result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(TransactedSnapshotImpl));
4283   if (*result)
4284   {
4285     (*result)->base.lpVtbl = &TransactedSnapshotImpl_Vtbl;
4286
4287     /* This is OK because the property set storage functions use the IStorage functions. */
4288     (*result)->base.pssVtbl = parentStorage->pssVtbl;
4289
4290     (*result)->base.baseVtbl = &TransactedSnapshotImpl_BaseVtbl;
4291
4292     list_init(&(*result)->base.strmHead);
4293
4294     list_init(&(*result)->base.storageHead);
4295
4296     (*result)->base.ref = 1;
4297
4298     (*result)->base.openFlags = parentStorage->openFlags;
4299
4300     (*result)->base.filename = parentStorage->filename;
4301
4302     /* Create a new temporary storage to act as the snapshot */
4303     hr = CreateSnapshotFile(parentStorage, &(*result)->snapshot);
4304
4305     if (SUCCEEDED(hr))
4306     {
4307         (*result)->base.storageDirEntry = (*result)->snapshot->storageDirEntry;
4308
4309         /* parentStorage already has 1 reference, which we take over here. */
4310         (*result)->transactedParent = parentStorage;
4311
4312         parentStorage->transactedChild = (StorageBaseImpl*)*result;
4313     }
4314
4315     if (FAILED(hr)) HeapFree(GetProcessHeap(), 0, (*result));
4316
4317     return hr;
4318   }
4319   else
4320     return E_OUTOFMEMORY;
4321 }
4322
4323 static HRESULT Storage_ConstructTransacted(StorageBaseImpl *parentStorage,
4324   StorageBaseImpl** result)
4325 {
4326   static int fixme=0;
4327
4328   if (parentStorage->openFlags & (STGM_NOSCRATCH|STGM_NOSNAPSHOT) && !fixme++)
4329   {
4330     FIXME("Unimplemented flags %x\n", parentStorage->openFlags);
4331   }
4332
4333   return TransactedSnapshotImpl_Construct(parentStorage,
4334     (TransactedSnapshotImpl**)result);
4335 }
4336
4337 static HRESULT Storage_Construct(
4338   HANDLE       hFile,
4339   LPCOLESTR    pwcsName,
4340   ILockBytes*  pLkbyt,
4341   DWORD        openFlags,
4342   BOOL         fileBased,
4343   BOOL         create,
4344   StorageBaseImpl** result)
4345 {
4346   StorageImpl *newStorage;
4347   StorageBaseImpl *newTransactedStorage;
4348   HRESULT hr;
4349
4350   hr = StorageImpl_Construct(hFile, pwcsName, pLkbyt, openFlags, fileBased, create, &newStorage);
4351   if (FAILED(hr)) goto end;
4352
4353   if (openFlags & STGM_TRANSACTED)
4354   {
4355     hr = Storage_ConstructTransacted(&newStorage->base, &newTransactedStorage);
4356     if (FAILED(hr))
4357       IStorage_Release((IStorage*)newStorage);
4358     else
4359       *result = newTransactedStorage;
4360   }
4361   else
4362     *result = &newStorage->base;
4363
4364 end:
4365   return hr;
4366 }
4367
4368 static void StorageInternalImpl_Invalidate( StorageBaseImpl *base )
4369 {
4370   StorageInternalImpl* This = (StorageInternalImpl*) base;
4371
4372   if (!This->base.reverted)
4373   {
4374     TRACE("Storage invalidated (stg=%p)\n", This);
4375
4376     This->base.reverted = 1;
4377
4378     This->parentStorage = NULL;
4379
4380     StorageBaseImpl_DeleteAll(&This->base);
4381
4382     list_remove(&This->ParentListEntry);
4383   }
4384 }
4385
4386 static void StorageInternalImpl_Destroy( StorageBaseImpl *iface)
4387 {
4388   StorageInternalImpl* This = (StorageInternalImpl*) iface;
4389
4390   StorageInternalImpl_Invalidate(&This->base);
4391
4392   HeapFree(GetProcessHeap(), 0, This);
4393 }
4394
4395 static HRESULT StorageInternalImpl_CreateDirEntry(StorageBaseImpl *base,
4396   const DirEntry *newData, DirRef *index)
4397 {
4398   StorageInternalImpl* This = (StorageInternalImpl*) base;
4399
4400   return StorageBaseImpl_CreateDirEntry(This->parentStorage,
4401     newData, index);
4402 }
4403
4404 static HRESULT StorageInternalImpl_WriteDirEntry(StorageBaseImpl *base,
4405   DirRef index, const DirEntry *data)
4406 {
4407   StorageInternalImpl* This = (StorageInternalImpl*) base;
4408
4409   return StorageBaseImpl_WriteDirEntry(This->parentStorage,
4410     index, data);
4411 }
4412
4413 static HRESULT StorageInternalImpl_ReadDirEntry(StorageBaseImpl *base,
4414   DirRef index, DirEntry *data)
4415 {
4416   StorageInternalImpl* This = (StorageInternalImpl*) base;
4417
4418   return StorageBaseImpl_ReadDirEntry(This->parentStorage,
4419     index, data);
4420 }
4421
4422 static HRESULT StorageInternalImpl_DestroyDirEntry(StorageBaseImpl *base,
4423   DirRef index)
4424 {
4425   StorageInternalImpl* This = (StorageInternalImpl*) base;
4426
4427   return StorageBaseImpl_DestroyDirEntry(This->parentStorage,
4428     index);
4429 }
4430
4431 static HRESULT StorageInternalImpl_StreamReadAt(StorageBaseImpl *base,
4432   DirRef index, ULARGE_INTEGER offset, ULONG size, void *buffer, ULONG *bytesRead)
4433 {
4434   StorageInternalImpl* This = (StorageInternalImpl*) base;
4435
4436   return StorageBaseImpl_StreamReadAt(This->parentStorage,
4437     index, offset, size, buffer, bytesRead);
4438 }
4439
4440 static HRESULT StorageInternalImpl_StreamWriteAt(StorageBaseImpl *base,
4441   DirRef index, ULARGE_INTEGER offset, ULONG size, const void *buffer, ULONG *bytesWritten)
4442 {
4443   StorageInternalImpl* This = (StorageInternalImpl*) base;
4444
4445   return StorageBaseImpl_StreamWriteAt(This->parentStorage,
4446     index, offset, size, buffer, bytesWritten);
4447 }
4448
4449 static HRESULT StorageInternalImpl_StreamSetSize(StorageBaseImpl *base,
4450   DirRef index, ULARGE_INTEGER newsize)
4451 {
4452   StorageInternalImpl* This = (StorageInternalImpl*) base;
4453
4454   return StorageBaseImpl_StreamSetSize(This->parentStorage,
4455     index, newsize);
4456 }
4457
4458 /******************************************************************************
4459 **
4460 ** Storage32InternalImpl_Commit
4461 **
4462 */
4463 static HRESULT WINAPI StorageInternalImpl_Commit(
4464   IStorage*            iface,
4465   DWORD                  grfCommitFlags)  /* [in] */
4466 {
4467   FIXME("(%p,%x): stub\n", iface, grfCommitFlags);
4468   return S_OK;
4469 }
4470
4471 /******************************************************************************
4472 **
4473 ** Storage32InternalImpl_Revert
4474 **
4475 */
4476 static HRESULT WINAPI StorageInternalImpl_Revert(
4477   IStorage*            iface)
4478 {
4479   FIXME("(%p): stub\n", iface);
4480   return S_OK;
4481 }
4482
4483 static void IEnumSTATSTGImpl_Destroy(IEnumSTATSTGImpl* This)
4484 {
4485   IStorage_Release((IStorage*)This->parentStorage);
4486   HeapFree(GetProcessHeap(), 0, This);
4487 }
4488
4489 static HRESULT WINAPI IEnumSTATSTGImpl_QueryInterface(
4490   IEnumSTATSTG*     iface,
4491   REFIID            riid,
4492   void**            ppvObject)
4493 {
4494   IEnumSTATSTGImpl* const This=(IEnumSTATSTGImpl*)iface;
4495
4496   if (ppvObject==0)
4497     return E_INVALIDARG;
4498
4499   *ppvObject = 0;
4500
4501   if (IsEqualGUID(&IID_IUnknown, riid) ||
4502       IsEqualGUID(&IID_IEnumSTATSTG, riid))
4503   {
4504     *ppvObject = This;
4505     IEnumSTATSTG_AddRef((IEnumSTATSTG*)This);
4506     return S_OK;
4507   }
4508
4509   return E_NOINTERFACE;
4510 }
4511
4512 static ULONG   WINAPI IEnumSTATSTGImpl_AddRef(
4513   IEnumSTATSTG* iface)
4514 {
4515   IEnumSTATSTGImpl* const This=(IEnumSTATSTGImpl*)iface;
4516   return InterlockedIncrement(&This->ref);
4517 }
4518
4519 static ULONG   WINAPI IEnumSTATSTGImpl_Release(
4520   IEnumSTATSTG* iface)
4521 {
4522   IEnumSTATSTGImpl* const This=(IEnumSTATSTGImpl*)iface;
4523
4524   ULONG newRef;
4525
4526   newRef = InterlockedDecrement(&This->ref);
4527
4528   if (newRef==0)
4529   {
4530     IEnumSTATSTGImpl_Destroy(This);
4531   }
4532
4533   return newRef;
4534 }
4535
4536 static HRESULT IEnumSTATSTGImpl_GetNextRef(
4537   IEnumSTATSTGImpl* This,
4538   DirRef *ref)
4539 {
4540   DirRef result = DIRENTRY_NULL;
4541   DirRef searchNode;
4542   DirEntry entry;
4543   HRESULT hr;
4544   WCHAR result_name[DIRENTRY_NAME_MAX_LEN];
4545
4546   hr = StorageBaseImpl_ReadDirEntry(This->parentStorage,
4547     This->parentStorage->storageDirEntry, &entry);
4548   searchNode = entry.dirRootEntry;
4549
4550   while (SUCCEEDED(hr) && searchNode != DIRENTRY_NULL)
4551   {
4552     hr = StorageBaseImpl_ReadDirEntry(This->parentStorage, searchNode, &entry);
4553
4554     if (SUCCEEDED(hr))
4555     {
4556       LONG diff = entryNameCmp( entry.name, This->name);
4557
4558       if (diff <= 0)
4559       {
4560         searchNode = entry.rightChild;
4561       }
4562       else
4563       {
4564         result = searchNode;
4565         memcpy(result_name, entry.name, sizeof(result_name));
4566         searchNode = entry.leftChild;
4567       }
4568     }
4569   }
4570
4571   if (SUCCEEDED(hr))
4572   {
4573     *ref = result;
4574     if (result != DIRENTRY_NULL)
4575       memcpy(This->name, result_name, sizeof(result_name));
4576   }
4577
4578   return hr;
4579 }
4580
4581 static HRESULT WINAPI IEnumSTATSTGImpl_Next(
4582   IEnumSTATSTG* iface,
4583   ULONG             celt,
4584   STATSTG*          rgelt,
4585   ULONG*            pceltFetched)
4586 {
4587   IEnumSTATSTGImpl* const This=(IEnumSTATSTGImpl*)iface;
4588
4589   DirEntry    currentEntry;
4590   STATSTG*    currentReturnStruct = rgelt;
4591   ULONG       objectFetched       = 0;
4592   DirRef      currentSearchNode;
4593   HRESULT     hr=S_OK;
4594
4595   if ( (rgelt==0) || ( (celt!=1) && (pceltFetched==0) ) )
4596     return E_INVALIDARG;
4597
4598   if (This->parentStorage->reverted)
4599     return STG_E_REVERTED;
4600
4601   /*
4602    * To avoid the special case, get another pointer to a ULONG value if
4603    * the caller didn't supply one.
4604    */
4605   if (pceltFetched==0)
4606     pceltFetched = &objectFetched;
4607
4608   /*
4609    * Start the iteration, we will iterate until we hit the end of the
4610    * linked list or until we hit the number of items to iterate through
4611    */
4612   *pceltFetched = 0;
4613
4614   while ( *pceltFetched < celt )
4615   {
4616     hr = IEnumSTATSTGImpl_GetNextRef(This, &currentSearchNode);
4617
4618     if (FAILED(hr) || currentSearchNode == DIRENTRY_NULL)
4619       break;
4620
4621     /*
4622      * Read the entry from the storage.
4623      */
4624     StorageBaseImpl_ReadDirEntry(This->parentStorage,
4625       currentSearchNode,
4626       &currentEntry);
4627
4628     /*
4629      * Copy the information to the return buffer.
4630      */
4631     StorageUtl_CopyDirEntryToSTATSTG(This->parentStorage,
4632       currentReturnStruct,
4633       &currentEntry,
4634       STATFLAG_DEFAULT);
4635
4636     /*
4637      * Step to the next item in the iteration
4638      */
4639     (*pceltFetched)++;
4640     currentReturnStruct++;
4641   }
4642
4643   if (SUCCEEDED(hr) && *pceltFetched != celt)
4644     hr = S_FALSE;
4645
4646   return hr;
4647 }
4648
4649
4650 static HRESULT WINAPI IEnumSTATSTGImpl_Skip(
4651   IEnumSTATSTG* iface,
4652   ULONG             celt)
4653 {
4654   IEnumSTATSTGImpl* const This=(IEnumSTATSTGImpl*)iface;
4655
4656   ULONG       objectFetched       = 0;
4657   DirRef      currentSearchNode;
4658   HRESULT     hr=S_OK;
4659
4660   if (This->parentStorage->reverted)
4661     return STG_E_REVERTED;
4662
4663   while ( (objectFetched < celt) )
4664   {
4665     hr = IEnumSTATSTGImpl_GetNextRef(This, &currentSearchNode);
4666
4667     if (FAILED(hr) || currentSearchNode == DIRENTRY_NULL)
4668       break;
4669
4670     objectFetched++;
4671   }
4672
4673   if (SUCCEEDED(hr) && objectFetched != celt)
4674     return S_FALSE;
4675
4676   return hr;
4677 }
4678
4679 static HRESULT WINAPI IEnumSTATSTGImpl_Reset(
4680   IEnumSTATSTG* iface)
4681 {
4682   IEnumSTATSTGImpl* const This=(IEnumSTATSTGImpl*)iface;
4683
4684   if (This->parentStorage->reverted)
4685     return STG_E_REVERTED;
4686
4687   This->name[0] = 0;
4688
4689   return S_OK;
4690 }
4691
4692 static HRESULT WINAPI IEnumSTATSTGImpl_Clone(
4693   IEnumSTATSTG* iface,
4694   IEnumSTATSTG**    ppenum)
4695 {
4696   IEnumSTATSTGImpl* const This=(IEnumSTATSTGImpl*)iface;
4697
4698   IEnumSTATSTGImpl* newClone;
4699
4700   if (This->parentStorage->reverted)
4701     return STG_E_REVERTED;
4702
4703   /*
4704    * Perform a sanity check on the parameters.
4705    */
4706   if (ppenum==0)
4707     return E_INVALIDARG;
4708
4709   newClone = IEnumSTATSTGImpl_Construct(This->parentStorage,
4710                This->storageDirEntry);
4711
4712
4713   /*
4714    * The new clone enumeration must point to the same current node as
4715    * the ole one.
4716    */
4717   memcpy(newClone->name, This->name, sizeof(newClone->name));
4718
4719   *ppenum = (IEnumSTATSTG*)newClone;
4720
4721   /*
4722    * Don't forget to nail down a reference to the clone before
4723    * returning it.
4724    */
4725   IEnumSTATSTGImpl_AddRef(*ppenum);
4726
4727   return S_OK;
4728 }
4729
4730 /*
4731  * Virtual function table for the IEnumSTATSTGImpl class.
4732  */
4733 static const IEnumSTATSTGVtbl IEnumSTATSTGImpl_Vtbl =
4734 {
4735     IEnumSTATSTGImpl_QueryInterface,
4736     IEnumSTATSTGImpl_AddRef,
4737     IEnumSTATSTGImpl_Release,
4738     IEnumSTATSTGImpl_Next,
4739     IEnumSTATSTGImpl_Skip,
4740     IEnumSTATSTGImpl_Reset,
4741     IEnumSTATSTGImpl_Clone
4742 };
4743
4744 /******************************************************************************
4745 ** IEnumSTATSTGImpl implementation
4746 */
4747
4748 static IEnumSTATSTGImpl* IEnumSTATSTGImpl_Construct(
4749   StorageBaseImpl* parentStorage,
4750   DirRef         storageDirEntry)
4751 {
4752   IEnumSTATSTGImpl* newEnumeration;
4753
4754   newEnumeration = HeapAlloc(GetProcessHeap(), 0, sizeof(IEnumSTATSTGImpl));
4755
4756   if (newEnumeration!=0)
4757   {
4758     /*
4759      * Set-up the virtual function table and reference count.
4760      */
4761     newEnumeration->lpVtbl    = &IEnumSTATSTGImpl_Vtbl;
4762     newEnumeration->ref       = 0;
4763
4764     /*
4765      * We want to nail-down the reference to the storage in case the
4766      * enumeration out-lives the storage in the client application.
4767      */
4768     newEnumeration->parentStorage = parentStorage;
4769     IStorage_AddRef((IStorage*)newEnumeration->parentStorage);
4770
4771     newEnumeration->storageDirEntry   = storageDirEntry;
4772
4773     /*
4774      * Make sure the current node of the iterator is the first one.
4775      */
4776     IEnumSTATSTGImpl_Reset((IEnumSTATSTG*)newEnumeration);
4777   }
4778
4779   return newEnumeration;
4780 }
4781
4782 /*
4783  * Virtual function table for the Storage32InternalImpl class.
4784  */
4785 static const IStorageVtbl Storage32InternalImpl_Vtbl =
4786 {
4787     StorageBaseImpl_QueryInterface,
4788     StorageBaseImpl_AddRef,
4789     StorageBaseImpl_Release,
4790     StorageBaseImpl_CreateStream,
4791     StorageBaseImpl_OpenStream,
4792     StorageBaseImpl_CreateStorage,
4793     StorageBaseImpl_OpenStorage,
4794     StorageBaseImpl_CopyTo,
4795     StorageBaseImpl_MoveElementTo,
4796     StorageInternalImpl_Commit,
4797     StorageInternalImpl_Revert,
4798     StorageBaseImpl_EnumElements,
4799     StorageBaseImpl_DestroyElement,
4800     StorageBaseImpl_RenameElement,
4801     StorageBaseImpl_SetElementTimes,
4802     StorageBaseImpl_SetClass,
4803     StorageBaseImpl_SetStateBits,
4804     StorageBaseImpl_Stat
4805 };
4806
4807 static const StorageBaseImplVtbl StorageInternalImpl_BaseVtbl =
4808 {
4809   StorageInternalImpl_Destroy,
4810   StorageInternalImpl_Invalidate,
4811   StorageInternalImpl_CreateDirEntry,
4812   StorageInternalImpl_WriteDirEntry,
4813   StorageInternalImpl_ReadDirEntry,
4814   StorageInternalImpl_DestroyDirEntry,
4815   StorageInternalImpl_StreamReadAt,
4816   StorageInternalImpl_StreamWriteAt,
4817   StorageInternalImpl_StreamSetSize
4818 };
4819
4820 /******************************************************************************
4821 ** Storage32InternalImpl implementation
4822 */
4823
4824 static StorageInternalImpl* StorageInternalImpl_Construct(
4825   StorageBaseImpl* parentStorage,
4826   DWORD        openFlags,
4827   DirRef       storageDirEntry)
4828 {
4829   StorageInternalImpl* newStorage;
4830
4831   newStorage = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(StorageInternalImpl));
4832
4833   if (newStorage!=0)
4834   {
4835     list_init(&newStorage->base.strmHead);
4836
4837     list_init(&newStorage->base.storageHead);
4838
4839     /*
4840      * Initialize the virtual function table.
4841      */
4842     newStorage->base.lpVtbl = &Storage32InternalImpl_Vtbl;
4843     newStorage->base.baseVtbl = &StorageInternalImpl_BaseVtbl;
4844     newStorage->base.openFlags = (openFlags & ~STGM_CREATE);
4845
4846     newStorage->base.reverted = 0;
4847
4848     newStorage->base.ref = 1;
4849
4850     newStorage->parentStorage = parentStorage;
4851
4852     /*
4853      * Keep a reference to the directory entry of this storage
4854      */
4855     newStorage->base.storageDirEntry = storageDirEntry;
4856
4857     newStorage->base.create = 0;
4858
4859     return newStorage;
4860   }
4861
4862   return 0;
4863 }
4864
4865 /******************************************************************************
4866 ** StorageUtl implementation
4867 */
4868
4869 void StorageUtl_ReadWord(const BYTE* buffer, ULONG offset, WORD* value)
4870 {
4871   WORD tmp;
4872
4873   memcpy(&tmp, buffer+offset, sizeof(WORD));
4874   *value = lendian16toh(tmp);
4875 }
4876
4877 void StorageUtl_WriteWord(BYTE* buffer, ULONG offset, WORD value)
4878 {
4879   value = htole16(value);
4880   memcpy(buffer+offset, &value, sizeof(WORD));
4881 }
4882
4883 void StorageUtl_ReadDWord(const BYTE* buffer, ULONG offset, DWORD* value)
4884 {
4885   DWORD tmp;
4886
4887   memcpy(&tmp, buffer+offset, sizeof(DWORD));
4888   *value = lendian32toh(tmp);
4889 }
4890
4891 void StorageUtl_WriteDWord(BYTE* buffer, ULONG offset, DWORD value)
4892 {
4893   value = htole32(value);
4894   memcpy(buffer+offset, &value, sizeof(DWORD));
4895 }
4896
4897 void StorageUtl_ReadULargeInteger(const BYTE* buffer, ULONG offset,
4898  ULARGE_INTEGER* value)
4899 {
4900 #ifdef WORDS_BIGENDIAN
4901     ULARGE_INTEGER tmp;
4902
4903     memcpy(&tmp, buffer + offset, sizeof(ULARGE_INTEGER));
4904     value->u.LowPart = htole32(tmp.u.HighPart);
4905     value->u.HighPart = htole32(tmp.u.LowPart);
4906 #else
4907     memcpy(value, buffer + offset, sizeof(ULARGE_INTEGER));
4908 #endif
4909 }
4910
4911 void StorageUtl_WriteULargeInteger(BYTE* buffer, ULONG offset,
4912  const ULARGE_INTEGER *value)
4913 {
4914 #ifdef WORDS_BIGENDIAN
4915     ULARGE_INTEGER tmp;
4916
4917     tmp.u.LowPart = htole32(value->u.HighPart);
4918     tmp.u.HighPart = htole32(value->u.LowPart);
4919     memcpy(buffer + offset, &tmp, sizeof(ULARGE_INTEGER));
4920 #else
4921     memcpy(buffer + offset, value, sizeof(ULARGE_INTEGER));
4922 #endif
4923 }
4924
4925 void StorageUtl_ReadGUID(const BYTE* buffer, ULONG offset, GUID* value)
4926 {
4927   StorageUtl_ReadDWord(buffer, offset,   &(value->Data1));
4928   StorageUtl_ReadWord(buffer,  offset+4, &(value->Data2));
4929   StorageUtl_ReadWord(buffer,  offset+6, &(value->Data3));
4930
4931   memcpy(value->Data4, buffer+offset+8, sizeof(value->Data4));
4932 }
4933
4934 void StorageUtl_WriteGUID(BYTE* buffer, ULONG offset, const GUID* value)
4935 {
4936   StorageUtl_WriteDWord(buffer, offset,   value->Data1);
4937   StorageUtl_WriteWord(buffer,  offset+4, value->Data2);
4938   StorageUtl_WriteWord(buffer,  offset+6, value->Data3);
4939
4940   memcpy(buffer+offset+8, value->Data4, sizeof(value->Data4));
4941 }
4942
4943 void StorageUtl_CopyDirEntryToSTATSTG(
4944   StorageBaseImpl*      storage,
4945   STATSTG*              destination,
4946   const DirEntry*       source,
4947   int                   statFlags)
4948 {
4949   LPCWSTR entryName;
4950
4951   if (source->stgType == STGTY_ROOT)
4952   {
4953     /* replace the name of root entry (often "Root Entry") by the file name */
4954     entryName = storage->filename;
4955   }
4956   else
4957   {
4958     entryName = source->name;
4959   }
4960
4961   /*
4962    * The copy of the string occurs only when the flag is not set
4963    */
4964   if( ((statFlags & STATFLAG_NONAME) != 0) ||
4965        (entryName == NULL) ||
4966        (entryName[0] == 0) )
4967   {
4968     destination->pwcsName = 0;
4969   }
4970   else
4971   {
4972     destination->pwcsName =
4973       CoTaskMemAlloc((lstrlenW(entryName)+1)*sizeof(WCHAR));
4974
4975     strcpyW(destination->pwcsName, entryName);
4976   }
4977
4978   switch (source->stgType)
4979   {
4980     case STGTY_STORAGE:
4981     case STGTY_ROOT:
4982       destination->type = STGTY_STORAGE;
4983       break;
4984     case STGTY_STREAM:
4985       destination->type = STGTY_STREAM;
4986       break;
4987     default:
4988       destination->type = STGTY_STREAM;
4989       break;
4990   }
4991
4992   destination->cbSize            = source->size;
4993 /*
4994   currentReturnStruct->mtime     = {0}; TODO
4995   currentReturnStruct->ctime     = {0};
4996   currentReturnStruct->atime     = {0};
4997 */
4998   destination->grfMode           = 0;
4999   destination->grfLocksSupported = 0;
5000   destination->clsid             = source->clsid;
5001   destination->grfStateBits      = 0;
5002   destination->reserved          = 0;
5003 }
5004
5005 /******************************************************************************
5006 ** BlockChainStream implementation
5007 */
5008
5009 BlockChainStream* BlockChainStream_Construct(
5010   StorageImpl* parentStorage,
5011   ULONG*         headOfStreamPlaceHolder,
5012   DirRef         dirEntry)
5013 {
5014   BlockChainStream* newStream;
5015   ULONG blockIndex;
5016
5017   newStream = HeapAlloc(GetProcessHeap(), 0, sizeof(BlockChainStream));
5018
5019   newStream->parentStorage           = parentStorage;
5020   newStream->headOfStreamPlaceHolder = headOfStreamPlaceHolder;
5021   newStream->ownerDirEntry           = dirEntry;
5022   newStream->lastBlockNoInSequence   = 0xFFFFFFFF;
5023   newStream->tailIndex               = BLOCK_END_OF_CHAIN;
5024   newStream->numBlocks               = 0;
5025
5026   blockIndex = BlockChainStream_GetHeadOfChain(newStream);
5027
5028   while (blockIndex != BLOCK_END_OF_CHAIN)
5029   {
5030     newStream->numBlocks++;
5031     newStream->tailIndex = blockIndex;
5032
5033     if(FAILED(StorageImpl_GetNextBlockInChain(
5034               parentStorage,
5035               blockIndex,
5036               &blockIndex)))
5037     {
5038       HeapFree(GetProcessHeap(), 0, newStream);
5039       return NULL;
5040     }
5041   }
5042
5043   return newStream;
5044 }
5045
5046 void BlockChainStream_Destroy(BlockChainStream* This)
5047 {
5048   HeapFree(GetProcessHeap(), 0, This);
5049 }
5050
5051 /******************************************************************************
5052  *      BlockChainStream_GetHeadOfChain
5053  *
5054  * Returns the head of this stream chain.
5055  * Some special chains don't have directory entries, their heads are kept in
5056  * This->headOfStreamPlaceHolder.
5057  *
5058  */
5059 static ULONG BlockChainStream_GetHeadOfChain(BlockChainStream* This)
5060 {
5061   DirEntry  chainEntry;
5062   HRESULT   hr;
5063
5064   if (This->headOfStreamPlaceHolder != 0)
5065     return *(This->headOfStreamPlaceHolder);
5066
5067   if (This->ownerDirEntry != DIRENTRY_NULL)
5068   {
5069     hr = StorageImpl_ReadDirEntry(
5070                       This->parentStorage,
5071                       This->ownerDirEntry,
5072                       &chainEntry);
5073
5074     if (SUCCEEDED(hr))
5075     {
5076       return chainEntry.startingBlock;
5077     }
5078   }
5079
5080   return BLOCK_END_OF_CHAIN;
5081 }
5082
5083 /******************************************************************************
5084  *       BlockChainStream_GetCount
5085  *
5086  * Returns the number of blocks that comprises this chain.
5087  * This is not the size of the stream as the last block may not be full!
5088  *
5089  */
5090 static ULONG BlockChainStream_GetCount(BlockChainStream* This)
5091 {
5092   ULONG blockIndex;
5093   ULONG count = 0;
5094
5095   blockIndex = BlockChainStream_GetHeadOfChain(This);
5096
5097   while (blockIndex != BLOCK_END_OF_CHAIN)
5098   {
5099     count++;
5100
5101     if(FAILED(StorageImpl_GetNextBlockInChain(
5102                    This->parentStorage,
5103                    blockIndex,
5104                    &blockIndex)))
5105       return 0;
5106   }
5107
5108   return count;
5109 }
5110
5111 /******************************************************************************
5112  *      BlockChainStream_ReadAt
5113  *
5114  * Reads a specified number of bytes from this chain at the specified offset.
5115  * bytesRead may be NULL.
5116  * Failure will be returned if the specified number of bytes has not been read.
5117  */
5118 HRESULT BlockChainStream_ReadAt(BlockChainStream* This,
5119   ULARGE_INTEGER offset,
5120   ULONG          size,
5121   void*          buffer,
5122   ULONG*         bytesRead)
5123 {
5124   ULONG blockNoInSequence = offset.u.LowPart / This->parentStorage->bigBlockSize;
5125   ULONG offsetInBlock     = offset.u.LowPart % This->parentStorage->bigBlockSize;
5126   ULONG bytesToReadInBuffer;
5127   ULONG blockIndex;
5128   BYTE* bufferWalker;
5129
5130   TRACE("(%p)-> %i %p %i %p\n",This, offset.u.LowPart, buffer, size, bytesRead);
5131
5132   /*
5133    * Find the first block in the stream that contains part of the buffer.
5134    */
5135   if ( (This->lastBlockNoInSequence == 0xFFFFFFFF) ||
5136        (This->lastBlockNoInSequenceIndex == BLOCK_END_OF_CHAIN) ||
5137        (blockNoInSequence < This->lastBlockNoInSequence) )
5138   {
5139     blockIndex = BlockChainStream_GetHeadOfChain(This);
5140     This->lastBlockNoInSequence = blockNoInSequence;
5141   }
5142   else
5143   {
5144     ULONG temp = blockNoInSequence;
5145
5146     blockIndex = This->lastBlockNoInSequenceIndex;
5147     blockNoInSequence -= This->lastBlockNoInSequence;
5148     This->lastBlockNoInSequence = temp;
5149   }
5150
5151   while ( (blockNoInSequence > 0) &&  (blockIndex != BLOCK_END_OF_CHAIN))
5152   {
5153     if(FAILED(StorageImpl_GetNextBlockInChain(This->parentStorage, blockIndex, &blockIndex)))
5154       return STG_E_DOCFILECORRUPT;
5155     blockNoInSequence--;
5156   }
5157
5158   if ((blockNoInSequence > 0) && (blockIndex == BLOCK_END_OF_CHAIN))
5159       return STG_E_DOCFILECORRUPT; /* We failed to find the starting block */
5160
5161   This->lastBlockNoInSequenceIndex = blockIndex;
5162
5163   /*
5164    * Start reading the buffer.
5165    */
5166   *bytesRead   = 0;
5167   bufferWalker = buffer;
5168
5169   while ( (size > 0) && (blockIndex != BLOCK_END_OF_CHAIN) )
5170   {
5171     ULARGE_INTEGER ulOffset;
5172     DWORD bytesReadAt;
5173     /*
5174      * Calculate how many bytes we can copy from this big block.
5175      */
5176     bytesToReadInBuffer =
5177       min(This->parentStorage->bigBlockSize - offsetInBlock, size);
5178
5179      TRACE("block %i\n",blockIndex);
5180      ulOffset.u.HighPart = 0;
5181      ulOffset.u.LowPart = StorageImpl_GetBigBlockOffset(This->parentStorage, blockIndex) +
5182                              offsetInBlock;
5183
5184      StorageImpl_ReadAt(This->parentStorage,
5185          ulOffset,
5186          bufferWalker,
5187          bytesToReadInBuffer,
5188          &bytesReadAt);
5189     /*
5190      * Step to the next big block.
5191      */
5192     if( size > bytesReadAt && FAILED(StorageImpl_GetNextBlockInChain(This->parentStorage, blockIndex, &blockIndex)))
5193       return STG_E_DOCFILECORRUPT;
5194
5195     bufferWalker += bytesReadAt;
5196     size         -= bytesReadAt;
5197     *bytesRead   += bytesReadAt;
5198     offsetInBlock = 0;  /* There is no offset on the next block */
5199
5200     if (bytesToReadInBuffer != bytesReadAt)
5201         break;
5202   }
5203
5204   return (size == 0) ? S_OK : STG_E_READFAULT;
5205 }
5206
5207 /******************************************************************************
5208  *      BlockChainStream_WriteAt
5209  *
5210  * Writes the specified number of bytes to this chain at the specified offset.
5211  * Will fail if not all specified number of bytes have been written.
5212  */
5213 HRESULT BlockChainStream_WriteAt(BlockChainStream* This,
5214   ULARGE_INTEGER    offset,
5215   ULONG             size,
5216   const void*       buffer,
5217   ULONG*            bytesWritten)
5218 {
5219   ULONG blockNoInSequence = offset.u.LowPart / This->parentStorage->bigBlockSize;
5220   ULONG offsetInBlock     = offset.u.LowPart % This->parentStorage->bigBlockSize;
5221   ULONG bytesToWrite;
5222   ULONG blockIndex;
5223   const BYTE* bufferWalker;
5224
5225   /*
5226    * Find the first block in the stream that contains part of the buffer.
5227    */
5228   if ( (This->lastBlockNoInSequence == 0xFFFFFFFF) ||
5229        (This->lastBlockNoInSequenceIndex == BLOCK_END_OF_CHAIN) ||
5230        (blockNoInSequence < This->lastBlockNoInSequence) )
5231   {
5232     blockIndex = BlockChainStream_GetHeadOfChain(This);
5233     This->lastBlockNoInSequence = blockNoInSequence;
5234   }
5235   else
5236   {
5237     ULONG temp = blockNoInSequence;
5238
5239     blockIndex = This->lastBlockNoInSequenceIndex;
5240     blockNoInSequence -= This->lastBlockNoInSequence;
5241     This->lastBlockNoInSequence = temp;
5242   }
5243
5244   while ( (blockNoInSequence > 0) &&  (blockIndex != BLOCK_END_OF_CHAIN))
5245   {
5246     if(FAILED(StorageImpl_GetNextBlockInChain(This->parentStorage, blockIndex,
5247                                               &blockIndex)))
5248       return STG_E_DOCFILECORRUPT;
5249     blockNoInSequence--;
5250   }
5251
5252   This->lastBlockNoInSequenceIndex = blockIndex;
5253
5254   /* BlockChainStream_SetSize should have already been called to ensure we have
5255    * enough blocks in the chain to write into */
5256   if (blockIndex == BLOCK_END_OF_CHAIN)
5257   {
5258     ERR("not enough blocks in chain to write data\n");
5259     return STG_E_DOCFILECORRUPT;
5260   }
5261
5262   *bytesWritten   = 0;
5263   bufferWalker = buffer;
5264
5265   while ( (size > 0) && (blockIndex != BLOCK_END_OF_CHAIN) )
5266   {
5267     ULARGE_INTEGER ulOffset;
5268     DWORD bytesWrittenAt;
5269     /*
5270      * Calculate how many bytes we can copy from this big block.
5271      */
5272     bytesToWrite =
5273       min(This->parentStorage->bigBlockSize - offsetInBlock, size);
5274
5275     TRACE("block %i\n",blockIndex);
5276     ulOffset.u.HighPart = 0;
5277     ulOffset.u.LowPart = StorageImpl_GetBigBlockOffset(This->parentStorage, blockIndex) +
5278                              offsetInBlock;
5279
5280     StorageImpl_WriteAt(This->parentStorage,
5281          ulOffset,
5282          bufferWalker,
5283          bytesToWrite,
5284          &bytesWrittenAt);
5285
5286     /*
5287      * Step to the next big block.
5288      */
5289     if(size > bytesWrittenAt && FAILED(StorageImpl_GetNextBlockInChain(This->parentStorage, blockIndex,
5290                                               &blockIndex)))
5291       return STG_E_DOCFILECORRUPT;
5292
5293     bufferWalker  += bytesWrittenAt;
5294     size          -= bytesWrittenAt;
5295     *bytesWritten += bytesWrittenAt;
5296     offsetInBlock  = 0;      /* There is no offset on the next block */
5297
5298     if (bytesWrittenAt != bytesToWrite)
5299       break;
5300   }
5301
5302   return (size == 0) ? S_OK : STG_E_WRITEFAULT;
5303 }
5304
5305 /******************************************************************************
5306  *      BlockChainStream_Shrink
5307  *
5308  * Shrinks this chain in the big block depot.
5309  */
5310 static BOOL BlockChainStream_Shrink(BlockChainStream* This,
5311                                     ULARGE_INTEGER    newSize)
5312 {
5313   ULONG blockIndex, extraBlock;
5314   ULONG numBlocks;
5315   ULONG count = 1;
5316
5317   /*
5318    * Reset the last accessed block cache.
5319    */
5320   This->lastBlockNoInSequence = 0xFFFFFFFF;
5321   This->lastBlockNoInSequenceIndex = BLOCK_END_OF_CHAIN;
5322
5323   /*
5324    * Figure out how many blocks are needed to contain the new size
5325    */
5326   numBlocks = newSize.u.LowPart / This->parentStorage->bigBlockSize;
5327
5328   if ((newSize.u.LowPart % This->parentStorage->bigBlockSize) != 0)
5329     numBlocks++;
5330
5331   blockIndex = BlockChainStream_GetHeadOfChain(This);
5332
5333   /*
5334    * Go to the new end of chain
5335    */
5336   while (count < numBlocks)
5337   {
5338     if(FAILED(StorageImpl_GetNextBlockInChain(This->parentStorage, blockIndex,
5339                                               &blockIndex)))
5340       return FALSE;
5341     count++;
5342   }
5343
5344   /* Get the next block before marking the new end */
5345   if(FAILED(StorageImpl_GetNextBlockInChain(This->parentStorage, blockIndex,
5346                                             &extraBlock)))
5347     return FALSE;
5348
5349   /* Mark the new end of chain */
5350   StorageImpl_SetNextBlockInChain(
5351     This->parentStorage,
5352     blockIndex,
5353     BLOCK_END_OF_CHAIN);
5354
5355   This->tailIndex = blockIndex;
5356   This->numBlocks = numBlocks;
5357
5358   /*
5359    * Mark the extra blocks as free
5360    */
5361   while (extraBlock != BLOCK_END_OF_CHAIN)
5362   {
5363     if(FAILED(StorageImpl_GetNextBlockInChain(This->parentStorage, extraBlock,
5364                                               &blockIndex)))
5365       return FALSE;
5366     StorageImpl_FreeBigBlock(This->parentStorage, extraBlock);
5367     extraBlock = blockIndex;
5368   }
5369
5370   return TRUE;
5371 }
5372
5373 /******************************************************************************
5374  *      BlockChainStream_Enlarge
5375  *
5376  * Grows this chain in the big block depot.
5377  */
5378 static BOOL BlockChainStream_Enlarge(BlockChainStream* This,
5379                                      ULARGE_INTEGER    newSize)
5380 {
5381   ULONG blockIndex, currentBlock;
5382   ULONG newNumBlocks;
5383   ULONG oldNumBlocks = 0;
5384
5385   blockIndex = BlockChainStream_GetHeadOfChain(This);
5386
5387   /*
5388    * Empty chain. Create the head.
5389    */
5390   if (blockIndex == BLOCK_END_OF_CHAIN)
5391   {
5392     blockIndex = StorageImpl_GetNextFreeBigBlock(This->parentStorage);
5393     StorageImpl_SetNextBlockInChain(This->parentStorage,
5394                                       blockIndex,
5395                                       BLOCK_END_OF_CHAIN);
5396
5397     if (This->headOfStreamPlaceHolder != 0)
5398     {
5399       *(This->headOfStreamPlaceHolder) = blockIndex;
5400     }
5401     else
5402     {
5403       DirEntry chainEntry;
5404       assert(This->ownerDirEntry != DIRENTRY_NULL);
5405
5406       StorageImpl_ReadDirEntry(
5407         This->parentStorage,
5408         This->ownerDirEntry,
5409         &chainEntry);
5410
5411       chainEntry.startingBlock = blockIndex;
5412
5413       StorageImpl_WriteDirEntry(
5414         This->parentStorage,
5415         This->ownerDirEntry,
5416         &chainEntry);
5417     }
5418
5419     This->tailIndex = blockIndex;
5420     This->numBlocks = 1;
5421   }
5422
5423   /*
5424    * Figure out how many blocks are needed to contain this stream
5425    */
5426   newNumBlocks = newSize.u.LowPart / This->parentStorage->bigBlockSize;
5427
5428   if ((newSize.u.LowPart % This->parentStorage->bigBlockSize) != 0)
5429     newNumBlocks++;
5430
5431   /*
5432    * Go to the current end of chain
5433    */
5434   if (This->tailIndex == BLOCK_END_OF_CHAIN)
5435   {
5436     currentBlock = blockIndex;
5437
5438     while (blockIndex != BLOCK_END_OF_CHAIN)
5439     {
5440       This->numBlocks++;
5441       currentBlock = blockIndex;
5442
5443       if(FAILED(StorageImpl_GetNextBlockInChain(This->parentStorage, currentBlock,
5444                                                 &blockIndex)))
5445         return FALSE;
5446     }
5447
5448     This->tailIndex = currentBlock;
5449   }
5450
5451   currentBlock = This->tailIndex;
5452   oldNumBlocks = This->numBlocks;
5453
5454   /*
5455    * Add new blocks to the chain
5456    */
5457   if (oldNumBlocks < newNumBlocks)
5458   {
5459     while (oldNumBlocks < newNumBlocks)
5460     {
5461       blockIndex = StorageImpl_GetNextFreeBigBlock(This->parentStorage);
5462
5463       StorageImpl_SetNextBlockInChain(
5464         This->parentStorage,
5465         currentBlock,
5466         blockIndex);
5467
5468       StorageImpl_SetNextBlockInChain(
5469         This->parentStorage,
5470         blockIndex,
5471         BLOCK_END_OF_CHAIN);
5472
5473       currentBlock = blockIndex;
5474       oldNumBlocks++;
5475     }
5476
5477     This->tailIndex = blockIndex;
5478     This->numBlocks = newNumBlocks;
5479   }
5480
5481   return TRUE;
5482 }
5483
5484 /******************************************************************************
5485  *      BlockChainStream_SetSize
5486  *
5487  * Sets the size of this stream. The big block depot will be updated.
5488  * The file will grow if we grow the chain.
5489  *
5490  * TODO: Free the actual blocks in the file when we shrink the chain.
5491  *       Currently, the blocks are still in the file. So the file size
5492  *       doesn't shrink even if we shrink streams.
5493  */
5494 BOOL BlockChainStream_SetSize(
5495   BlockChainStream* This,
5496   ULARGE_INTEGER    newSize)
5497 {
5498   ULARGE_INTEGER size = BlockChainStream_GetSize(This);
5499
5500   if (newSize.u.LowPart == size.u.LowPart)
5501     return TRUE;
5502
5503   if (newSize.u.LowPart < size.u.LowPart)
5504   {
5505     BlockChainStream_Shrink(This, newSize);
5506   }
5507   else
5508   {
5509     BlockChainStream_Enlarge(This, newSize);
5510   }
5511
5512   return TRUE;
5513 }
5514
5515 /******************************************************************************
5516  *      BlockChainStream_GetSize
5517  *
5518  * Returns the size of this chain.
5519  * Will return the block count if this chain doesn't have a directory entry.
5520  */
5521 static ULARGE_INTEGER BlockChainStream_GetSize(BlockChainStream* This)
5522 {
5523   DirEntry chainEntry;
5524
5525   if(This->headOfStreamPlaceHolder == NULL)
5526   {
5527     /*
5528      * This chain has a directory entry so use the size value from there.
5529      */
5530     StorageImpl_ReadDirEntry(
5531       This->parentStorage,
5532       This->ownerDirEntry,
5533       &chainEntry);
5534
5535     return chainEntry.size;
5536   }
5537   else
5538   {
5539     /*
5540      * this chain is a chain that does not have a directory entry, figure out the
5541      * size by making the product number of used blocks times the
5542      * size of them
5543      */
5544     ULARGE_INTEGER result;
5545     result.u.HighPart = 0;
5546
5547     result.u.LowPart  =
5548       BlockChainStream_GetCount(This) *
5549       This->parentStorage->bigBlockSize;
5550
5551     return result;
5552   }
5553 }
5554
5555 /******************************************************************************
5556 ** SmallBlockChainStream implementation
5557 */
5558
5559 SmallBlockChainStream* SmallBlockChainStream_Construct(
5560   StorageImpl* parentStorage,
5561   ULONG*         headOfStreamPlaceHolder,
5562   DirRef         dirEntry)
5563 {
5564   SmallBlockChainStream* newStream;
5565
5566   newStream = HeapAlloc(GetProcessHeap(), 0, sizeof(SmallBlockChainStream));
5567
5568   newStream->parentStorage      = parentStorage;
5569   newStream->headOfStreamPlaceHolder = headOfStreamPlaceHolder;
5570   newStream->ownerDirEntry      = dirEntry;
5571
5572   return newStream;
5573 }
5574
5575 void SmallBlockChainStream_Destroy(
5576   SmallBlockChainStream* This)
5577 {
5578   HeapFree(GetProcessHeap(), 0, This);
5579 }
5580
5581 /******************************************************************************
5582  *      SmallBlockChainStream_GetHeadOfChain
5583  *
5584  * Returns the head of this chain of small blocks.
5585  */
5586 static ULONG SmallBlockChainStream_GetHeadOfChain(
5587   SmallBlockChainStream* This)
5588 {
5589   DirEntry  chainEntry;
5590   HRESULT   hr;
5591
5592   if (This->headOfStreamPlaceHolder != NULL)
5593     return *(This->headOfStreamPlaceHolder);
5594
5595   if (This->ownerDirEntry)
5596   {
5597     hr = StorageImpl_ReadDirEntry(
5598                       This->parentStorage,
5599                       This->ownerDirEntry,
5600                       &chainEntry);
5601
5602     if (SUCCEEDED(hr))
5603     {
5604       return chainEntry.startingBlock;
5605     }
5606
5607   }
5608
5609   return BLOCK_END_OF_CHAIN;
5610 }
5611
5612 /******************************************************************************
5613  *      SmallBlockChainStream_GetNextBlockInChain
5614  *
5615  * Returns the index of the next small block in this chain.
5616  *
5617  * Return Values:
5618  *    - BLOCK_END_OF_CHAIN: end of this chain
5619  *    - BLOCK_UNUSED: small block 'blockIndex' is free
5620  */
5621 static HRESULT SmallBlockChainStream_GetNextBlockInChain(
5622   SmallBlockChainStream* This,
5623   ULONG                  blockIndex,
5624   ULONG*                 nextBlockInChain)
5625 {
5626   ULARGE_INTEGER offsetOfBlockInDepot;
5627   DWORD  buffer;
5628   ULONG  bytesRead;
5629   HRESULT res;
5630
5631   *nextBlockInChain = BLOCK_END_OF_CHAIN;
5632
5633   offsetOfBlockInDepot.u.HighPart = 0;
5634   offsetOfBlockInDepot.u.LowPart  = blockIndex * sizeof(ULONG);
5635
5636   /*
5637    * Read those bytes in the buffer from the small block file.
5638    */
5639   res = BlockChainStream_ReadAt(
5640               This->parentStorage->smallBlockDepotChain,
5641               offsetOfBlockInDepot,
5642               sizeof(DWORD),
5643               &buffer,
5644               &bytesRead);
5645
5646   if (SUCCEEDED(res))
5647   {
5648     StorageUtl_ReadDWord((BYTE *)&buffer, 0, nextBlockInChain);
5649     return S_OK;
5650   }
5651
5652   return res;
5653 }
5654
5655 /******************************************************************************
5656  *       SmallBlockChainStream_SetNextBlockInChain
5657  *
5658  * Writes the index of the next block of the specified block in the small
5659  * block depot.
5660  * To set the end of chain use BLOCK_END_OF_CHAIN as nextBlock.
5661  * To flag a block as free use BLOCK_UNUSED as nextBlock.
5662  */
5663 static void SmallBlockChainStream_SetNextBlockInChain(
5664   SmallBlockChainStream* This,
5665   ULONG                  blockIndex,
5666   ULONG                  nextBlock)
5667 {
5668   ULARGE_INTEGER offsetOfBlockInDepot;
5669   DWORD  buffer;
5670   ULONG  bytesWritten;
5671
5672   offsetOfBlockInDepot.u.HighPart = 0;
5673   offsetOfBlockInDepot.u.LowPart  = blockIndex * sizeof(ULONG);
5674
5675   StorageUtl_WriteDWord((BYTE *)&buffer, 0, nextBlock);
5676
5677   /*
5678    * Read those bytes in the buffer from the small block file.
5679    */
5680   BlockChainStream_WriteAt(
5681     This->parentStorage->smallBlockDepotChain,
5682     offsetOfBlockInDepot,
5683     sizeof(DWORD),
5684     &buffer,
5685     &bytesWritten);
5686 }
5687
5688 /******************************************************************************
5689  *      SmallBlockChainStream_FreeBlock
5690  *
5691  * Flag small block 'blockIndex' as free in the small block depot.
5692  */
5693 static void SmallBlockChainStream_FreeBlock(
5694   SmallBlockChainStream* This,
5695   ULONG                  blockIndex)
5696 {
5697   SmallBlockChainStream_SetNextBlockInChain(This, blockIndex, BLOCK_UNUSED);
5698 }
5699
5700 /******************************************************************************
5701  *      SmallBlockChainStream_GetNextFreeBlock
5702  *
5703  * Returns the index of a free small block. The small block depot will be
5704  * enlarged if necessary. The small block chain will also be enlarged if
5705  * necessary.
5706  */
5707 static ULONG SmallBlockChainStream_GetNextFreeBlock(
5708   SmallBlockChainStream* This)
5709 {
5710   ULARGE_INTEGER offsetOfBlockInDepot;
5711   DWORD buffer;
5712   ULONG bytesRead;
5713   ULONG blockIndex = 0;
5714   ULONG nextBlockIndex = BLOCK_END_OF_CHAIN;
5715   HRESULT res = S_OK;
5716   ULONG smallBlocksPerBigBlock;
5717
5718   offsetOfBlockInDepot.u.HighPart = 0;
5719
5720   /*
5721    * Scan the small block depot for a free block
5722    */
5723   while (nextBlockIndex != BLOCK_UNUSED)
5724   {
5725     offsetOfBlockInDepot.u.LowPart = blockIndex * sizeof(ULONG);
5726
5727     res = BlockChainStream_ReadAt(
5728                 This->parentStorage->smallBlockDepotChain,
5729                 offsetOfBlockInDepot,
5730                 sizeof(DWORD),
5731                 &buffer,
5732                 &bytesRead);
5733
5734     /*
5735      * If we run out of space for the small block depot, enlarge it
5736      */
5737     if (SUCCEEDED(res))
5738     {
5739       StorageUtl_ReadDWord((BYTE *)&buffer, 0, &nextBlockIndex);
5740
5741       if (nextBlockIndex != BLOCK_UNUSED)
5742         blockIndex++;
5743     }
5744     else
5745     {
5746       ULONG count =
5747         BlockChainStream_GetCount(This->parentStorage->smallBlockDepotChain);
5748
5749       ULONG sbdIndex = This->parentStorage->smallBlockDepotStart;
5750       ULONG nextBlock, newsbdIndex;
5751       BYTE smallBlockDepot[MAX_BIG_BLOCK_SIZE];
5752
5753       nextBlock = sbdIndex;
5754       while (nextBlock != BLOCK_END_OF_CHAIN)
5755       {
5756         sbdIndex = nextBlock;
5757         StorageImpl_GetNextBlockInChain(This->parentStorage, sbdIndex, &nextBlock);
5758       }
5759
5760       newsbdIndex = StorageImpl_GetNextFreeBigBlock(This->parentStorage);
5761       if (sbdIndex != BLOCK_END_OF_CHAIN)
5762         StorageImpl_SetNextBlockInChain(
5763           This->parentStorage,
5764           sbdIndex,
5765           newsbdIndex);
5766
5767       StorageImpl_SetNextBlockInChain(
5768         This->parentStorage,
5769         newsbdIndex,
5770         BLOCK_END_OF_CHAIN);
5771
5772       /*
5773        * Initialize all the small blocks to free
5774        */
5775       memset(smallBlockDepot, BLOCK_UNUSED, This->parentStorage->bigBlockSize);
5776       StorageImpl_WriteBigBlock(This->parentStorage, newsbdIndex, smallBlockDepot);
5777
5778       if (count == 0)
5779       {
5780         /*
5781          * We have just created the small block depot.
5782          */
5783         DirEntry rootEntry;
5784         ULONG sbStartIndex;
5785
5786         /*
5787          * Save it in the header
5788          */
5789         This->parentStorage->smallBlockDepotStart = newsbdIndex;
5790         StorageImpl_SaveFileHeader(This->parentStorage);
5791
5792         /*
5793          * And allocate the first big block that will contain small blocks
5794          */
5795         sbStartIndex =
5796           StorageImpl_GetNextFreeBigBlock(This->parentStorage);
5797
5798         StorageImpl_SetNextBlockInChain(
5799           This->parentStorage,
5800           sbStartIndex,
5801           BLOCK_END_OF_CHAIN);
5802
5803         StorageImpl_ReadDirEntry(
5804           This->parentStorage,
5805           This->parentStorage->base.storageDirEntry,
5806           &rootEntry);
5807
5808         rootEntry.startingBlock = sbStartIndex;
5809         rootEntry.size.u.HighPart = 0;
5810         rootEntry.size.u.LowPart  = This->parentStorage->bigBlockSize;
5811
5812         StorageImpl_WriteDirEntry(
5813           This->parentStorage,
5814           This->parentStorage->base.storageDirEntry,
5815           &rootEntry);
5816       }
5817       else
5818         StorageImpl_SaveFileHeader(This->parentStorage);
5819     }
5820   }
5821
5822   smallBlocksPerBigBlock =
5823     This->parentStorage->bigBlockSize / This->parentStorage->smallBlockSize;
5824
5825   /*
5826    * Verify if we have to allocate big blocks to contain small blocks
5827    */
5828   if (blockIndex % smallBlocksPerBigBlock == 0)
5829   {
5830     DirEntry rootEntry;
5831     ULONG blocksRequired = (blockIndex / smallBlocksPerBigBlock) + 1;
5832
5833     StorageImpl_ReadDirEntry(
5834       This->parentStorage,
5835       This->parentStorage->base.storageDirEntry,
5836       &rootEntry);
5837
5838     if (rootEntry.size.u.LowPart <
5839        (blocksRequired * This->parentStorage->bigBlockSize))
5840     {
5841       rootEntry.size.u.LowPart += This->parentStorage->bigBlockSize;
5842
5843       BlockChainStream_SetSize(
5844         This->parentStorage->smallBlockRootChain,
5845         rootEntry.size);
5846
5847       StorageImpl_WriteDirEntry(
5848         This->parentStorage,
5849         This->parentStorage->base.storageDirEntry,
5850         &rootEntry);
5851     }
5852   }
5853
5854   return blockIndex;
5855 }
5856
5857 /******************************************************************************
5858  *      SmallBlockChainStream_ReadAt
5859  *
5860  * Reads a specified number of bytes from this chain at the specified offset.
5861  * bytesRead may be NULL.
5862  * Failure will be returned if the specified number of bytes has not been read.
5863  */
5864 HRESULT SmallBlockChainStream_ReadAt(
5865   SmallBlockChainStream* This,
5866   ULARGE_INTEGER         offset,
5867   ULONG                  size,
5868   void*                  buffer,
5869   ULONG*                 bytesRead)
5870 {
5871   HRESULT rc = S_OK;
5872   ULARGE_INTEGER offsetInBigBlockFile;
5873   ULONG blockNoInSequence =
5874     offset.u.LowPart / This->parentStorage->smallBlockSize;
5875
5876   ULONG offsetInBlock = offset.u.LowPart % This->parentStorage->smallBlockSize;
5877   ULONG bytesToReadInBuffer;
5878   ULONG blockIndex;
5879   ULONG bytesReadFromBigBlockFile;
5880   BYTE* bufferWalker;
5881
5882   /*
5883    * This should never happen on a small block file.
5884    */
5885   assert(offset.u.HighPart==0);
5886
5887   /*
5888    * Find the first block in the stream that contains part of the buffer.
5889    */
5890   blockIndex = SmallBlockChainStream_GetHeadOfChain(This);
5891
5892   while ( (blockNoInSequence > 0) &&  (blockIndex != BLOCK_END_OF_CHAIN))
5893   {
5894     rc = SmallBlockChainStream_GetNextBlockInChain(This, blockIndex, &blockIndex);
5895     if(FAILED(rc))
5896       return rc;
5897     blockNoInSequence--;
5898   }
5899
5900   /*
5901    * Start reading the buffer.
5902    */
5903   *bytesRead   = 0;
5904   bufferWalker = buffer;
5905
5906   while ( (size > 0) && (blockIndex != BLOCK_END_OF_CHAIN) )
5907   {
5908     /*
5909      * Calculate how many bytes we can copy from this small block.
5910      */
5911     bytesToReadInBuffer =
5912       min(This->parentStorage->smallBlockSize - offsetInBlock, size);
5913
5914     /*
5915      * Calculate the offset of the small block in the small block file.
5916      */
5917     offsetInBigBlockFile.u.HighPart  = 0;
5918     offsetInBigBlockFile.u.LowPart   =
5919       blockIndex * This->parentStorage->smallBlockSize;
5920
5921     offsetInBigBlockFile.u.LowPart  += offsetInBlock;
5922
5923     /*
5924      * Read those bytes in the buffer from the small block file.
5925      * The small block has already been identified so it shouldn't fail
5926      * unless the file is corrupt.
5927      */
5928     rc = BlockChainStream_ReadAt(This->parentStorage->smallBlockRootChain,
5929       offsetInBigBlockFile,
5930       bytesToReadInBuffer,
5931       bufferWalker,
5932       &bytesReadFromBigBlockFile);
5933
5934     if (FAILED(rc))
5935       return rc;
5936
5937     /*
5938      * Step to the next big block.
5939      */
5940     rc = SmallBlockChainStream_GetNextBlockInChain(This, blockIndex, &blockIndex);
5941     if(FAILED(rc))
5942       return STG_E_DOCFILECORRUPT;
5943
5944     bufferWalker += bytesReadFromBigBlockFile;
5945     size         -= bytesReadFromBigBlockFile;
5946     *bytesRead   += bytesReadFromBigBlockFile;
5947     offsetInBlock = (offsetInBlock + bytesReadFromBigBlockFile) % This->parentStorage->smallBlockSize;
5948   }
5949
5950   return (size == 0) ? S_OK : STG_E_READFAULT;
5951 }
5952
5953 /******************************************************************************
5954  *       SmallBlockChainStream_WriteAt
5955  *
5956  * Writes the specified number of bytes to this chain at the specified offset.
5957  * Will fail if not all specified number of bytes have been written.
5958  */
5959 HRESULT SmallBlockChainStream_WriteAt(
5960   SmallBlockChainStream* This,
5961   ULARGE_INTEGER offset,
5962   ULONG          size,
5963   const void*    buffer,
5964   ULONG*         bytesWritten)
5965 {
5966   ULARGE_INTEGER offsetInBigBlockFile;
5967   ULONG blockNoInSequence =
5968     offset.u.LowPart / This->parentStorage->smallBlockSize;
5969
5970   ULONG offsetInBlock = offset.u.LowPart % This->parentStorage->smallBlockSize;
5971   ULONG bytesToWriteInBuffer;
5972   ULONG blockIndex;
5973   ULONG bytesWrittenToBigBlockFile;
5974   const BYTE* bufferWalker;
5975   HRESULT res;
5976
5977   /*
5978    * This should never happen on a small block file.
5979    */
5980   assert(offset.u.HighPart==0);
5981
5982   /*
5983    * Find the first block in the stream that contains part of the buffer.
5984    */
5985   blockIndex = SmallBlockChainStream_GetHeadOfChain(This);
5986
5987   while ( (blockNoInSequence > 0) &&  (blockIndex != BLOCK_END_OF_CHAIN))
5988   {
5989     if(FAILED(SmallBlockChainStream_GetNextBlockInChain(This, blockIndex, &blockIndex)))
5990       return STG_E_DOCFILECORRUPT;
5991     blockNoInSequence--;
5992   }
5993
5994   /*
5995    * Start writing the buffer.
5996    */
5997   *bytesWritten   = 0;
5998   bufferWalker = buffer;
5999   while ( (size > 0) && (blockIndex != BLOCK_END_OF_CHAIN) )
6000   {
6001     /*
6002      * Calculate how many bytes we can copy to this small block.
6003      */
6004     bytesToWriteInBuffer =
6005       min(This->parentStorage->smallBlockSize - offsetInBlock, size);
6006
6007     /*
6008      * Calculate the offset of the small block in the small block file.
6009      */
6010     offsetInBigBlockFile.u.HighPart  = 0;
6011     offsetInBigBlockFile.u.LowPart   =
6012       blockIndex * This->parentStorage->smallBlockSize;
6013
6014     offsetInBigBlockFile.u.LowPart  += offsetInBlock;
6015
6016     /*
6017      * Write those bytes in the buffer to the small block file.
6018      */
6019     res = BlockChainStream_WriteAt(
6020       This->parentStorage->smallBlockRootChain,
6021       offsetInBigBlockFile,
6022       bytesToWriteInBuffer,
6023       bufferWalker,
6024       &bytesWrittenToBigBlockFile);
6025     if (FAILED(res))
6026       return res;
6027
6028     /*
6029      * Step to the next big block.
6030      */
6031     if(FAILED(SmallBlockChainStream_GetNextBlockInChain(This, blockIndex,
6032                                                         &blockIndex)))
6033       return FALSE;
6034     bufferWalker  += bytesWrittenToBigBlockFile;
6035     size          -= bytesWrittenToBigBlockFile;
6036     *bytesWritten += bytesWrittenToBigBlockFile;
6037     offsetInBlock  = (offsetInBlock + bytesWrittenToBigBlockFile) % This->parentStorage->smallBlockSize;
6038   }
6039
6040   return (size == 0) ? S_OK : STG_E_WRITEFAULT;
6041 }
6042
6043 /******************************************************************************
6044  *       SmallBlockChainStream_Shrink
6045  *
6046  * Shrinks this chain in the small block depot.
6047  */
6048 static BOOL SmallBlockChainStream_Shrink(
6049   SmallBlockChainStream* This,
6050   ULARGE_INTEGER newSize)
6051 {
6052   ULONG blockIndex, extraBlock;
6053   ULONG numBlocks;
6054   ULONG count = 0;
6055
6056   numBlocks = newSize.u.LowPart / This->parentStorage->smallBlockSize;
6057
6058   if ((newSize.u.LowPart % This->parentStorage->smallBlockSize) != 0)
6059     numBlocks++;
6060
6061   blockIndex = SmallBlockChainStream_GetHeadOfChain(This);
6062
6063   /*
6064    * Go to the new end of chain
6065    */
6066   while (count < numBlocks)
6067   {
6068     if(FAILED(SmallBlockChainStream_GetNextBlockInChain(This, blockIndex,
6069                                                         &blockIndex)))
6070       return FALSE;
6071     count++;
6072   }
6073
6074   /*
6075    * If the count is 0, we have a special case, the head of the chain was
6076    * just freed.
6077    */
6078   if (count == 0)
6079   {
6080     DirEntry chainEntry;
6081
6082     StorageImpl_ReadDirEntry(This->parentStorage,
6083                              This->ownerDirEntry,
6084                              &chainEntry);
6085
6086     chainEntry.startingBlock = BLOCK_END_OF_CHAIN;
6087
6088     StorageImpl_WriteDirEntry(This->parentStorage,
6089                               This->ownerDirEntry,
6090                               &chainEntry);
6091
6092     /*
6093      * We start freeing the chain at the head block.
6094      */
6095     extraBlock = blockIndex;
6096   }
6097   else
6098   {
6099     /* Get the next block before marking the new end */
6100     if(FAILED(SmallBlockChainStream_GetNextBlockInChain(This, blockIndex,
6101                                                         &extraBlock)))
6102       return FALSE;
6103
6104     /* Mark the new end of chain */
6105     SmallBlockChainStream_SetNextBlockInChain(
6106       This,
6107       blockIndex,
6108       BLOCK_END_OF_CHAIN);
6109   }
6110
6111   /*
6112    * Mark the extra blocks as free
6113    */
6114   while (extraBlock != BLOCK_END_OF_CHAIN)
6115   {
6116     if(FAILED(SmallBlockChainStream_GetNextBlockInChain(This, extraBlock,
6117                                                         &blockIndex)))
6118       return FALSE;
6119     SmallBlockChainStream_FreeBlock(This, extraBlock);
6120     extraBlock = blockIndex;
6121   }
6122
6123   return TRUE;
6124 }
6125
6126 /******************************************************************************
6127  *      SmallBlockChainStream_Enlarge
6128  *
6129  * Grows this chain in the small block depot.
6130  */
6131 static BOOL SmallBlockChainStream_Enlarge(
6132   SmallBlockChainStream* This,
6133   ULARGE_INTEGER newSize)
6134 {
6135   ULONG blockIndex, currentBlock;
6136   ULONG newNumBlocks;
6137   ULONG oldNumBlocks = 0;
6138
6139   blockIndex = SmallBlockChainStream_GetHeadOfChain(This);
6140
6141   /*
6142    * Empty chain. Create the head.
6143    */
6144   if (blockIndex == BLOCK_END_OF_CHAIN)
6145   {
6146     blockIndex = SmallBlockChainStream_GetNextFreeBlock(This);
6147     SmallBlockChainStream_SetNextBlockInChain(
6148         This,
6149         blockIndex,
6150         BLOCK_END_OF_CHAIN);
6151
6152     if (This->headOfStreamPlaceHolder != NULL)
6153     {
6154       *(This->headOfStreamPlaceHolder) = blockIndex;
6155     }
6156     else
6157     {
6158       DirEntry chainEntry;
6159
6160       StorageImpl_ReadDirEntry(This->parentStorage, This->ownerDirEntry,
6161                                    &chainEntry);
6162
6163       chainEntry.startingBlock = blockIndex;
6164
6165       StorageImpl_WriteDirEntry(This->parentStorage, This->ownerDirEntry,
6166                                   &chainEntry);
6167     }
6168   }
6169
6170   currentBlock = blockIndex;
6171
6172   /*
6173    * Figure out how many blocks are needed to contain this stream
6174    */
6175   newNumBlocks = newSize.u.LowPart / This->parentStorage->smallBlockSize;
6176
6177   if ((newSize.u.LowPart % This->parentStorage->smallBlockSize) != 0)
6178     newNumBlocks++;
6179
6180   /*
6181    * Go to the current end of chain
6182    */
6183   while (blockIndex != BLOCK_END_OF_CHAIN)
6184   {
6185     oldNumBlocks++;
6186     currentBlock = blockIndex;
6187     if(FAILED(SmallBlockChainStream_GetNextBlockInChain(This, currentBlock, &blockIndex)))
6188       return FALSE;
6189   }
6190
6191   /*
6192    * Add new blocks to the chain
6193    */
6194   while (oldNumBlocks < newNumBlocks)
6195   {
6196     blockIndex = SmallBlockChainStream_GetNextFreeBlock(This);
6197     SmallBlockChainStream_SetNextBlockInChain(This, currentBlock, blockIndex);
6198
6199     SmallBlockChainStream_SetNextBlockInChain(
6200       This,
6201       blockIndex,
6202       BLOCK_END_OF_CHAIN);
6203
6204     currentBlock = blockIndex;
6205     oldNumBlocks++;
6206   }
6207
6208   return TRUE;
6209 }
6210
6211 /******************************************************************************
6212  *      SmallBlockChainStream_SetSize
6213  *
6214  * Sets the size of this stream.
6215  * The file will grow if we grow the chain.
6216  *
6217  * TODO: Free the actual blocks in the file when we shrink the chain.
6218  *       Currently, the blocks are still in the file. So the file size
6219  *       doesn't shrink even if we shrink streams.
6220  */
6221 BOOL SmallBlockChainStream_SetSize(
6222                 SmallBlockChainStream* This,
6223                 ULARGE_INTEGER    newSize)
6224 {
6225   ULARGE_INTEGER size = SmallBlockChainStream_GetSize(This);
6226
6227   if (newSize.u.LowPart == size.u.LowPart)
6228     return TRUE;
6229
6230   if (newSize.u.LowPart < size.u.LowPart)
6231   {
6232     SmallBlockChainStream_Shrink(This, newSize);
6233   }
6234   else
6235   {
6236     SmallBlockChainStream_Enlarge(This, newSize);
6237   }
6238
6239   return TRUE;
6240 }
6241
6242 /******************************************************************************
6243  *       SmallBlockChainStream_GetCount
6244  *
6245  * Returns the number of small blocks that comprises this chain.
6246  * This is not the size of the stream as the last block may not be full!
6247  *
6248  */
6249 static ULONG SmallBlockChainStream_GetCount(SmallBlockChainStream* This)
6250 {
6251     ULONG blockIndex;
6252     ULONG count = 0;
6253
6254     blockIndex = SmallBlockChainStream_GetHeadOfChain(This);
6255
6256     while(blockIndex != BLOCK_END_OF_CHAIN)
6257     {
6258         count++;
6259
6260         if(FAILED(SmallBlockChainStream_GetNextBlockInChain(This,
6261                         blockIndex, &blockIndex)))
6262             return 0;
6263     }
6264
6265     return count;
6266 }
6267
6268 /******************************************************************************
6269  *      SmallBlockChainStream_GetSize
6270  *
6271  * Returns the size of this chain.
6272  */
6273 static ULARGE_INTEGER SmallBlockChainStream_GetSize(SmallBlockChainStream* This)
6274 {
6275   DirEntry chainEntry;
6276
6277   if(This->headOfStreamPlaceHolder != NULL)
6278   {
6279     ULARGE_INTEGER result;
6280     result.u.HighPart = 0;
6281
6282     result.u.LowPart = SmallBlockChainStream_GetCount(This) *
6283         This->parentStorage->smallBlockSize;
6284
6285     return result;
6286   }
6287
6288   StorageImpl_ReadDirEntry(
6289     This->parentStorage,
6290     This->ownerDirEntry,
6291     &chainEntry);
6292
6293   return chainEntry.size;
6294 }
6295
6296 /******************************************************************************
6297  *    StgCreateDocfile  [OLE32.@]
6298  * Creates a new compound file storage object
6299  *
6300  * PARAMS
6301  *  pwcsName  [ I] Unicode string with filename (can be relative or NULL)
6302  *  grfMode   [ I] Access mode for opening the new storage object (see STGM_ constants)
6303  *  reserved  [ ?] unused?, usually 0
6304  *  ppstgOpen [IO] A pointer to IStorage pointer to the new onject
6305  *
6306  * RETURNS
6307  *  S_OK if the file was successfully created
6308  *  some STG_E_ value if error
6309  * NOTES
6310  *  if pwcsName is NULL, create file with new unique name
6311  *  the function can returns
6312  *  STG_S_CONVERTED if the specified file was successfully converted to storage format
6313  *  (unrealized now)
6314  */
6315 HRESULT WINAPI StgCreateDocfile(
6316   LPCOLESTR pwcsName,
6317   DWORD       grfMode,
6318   DWORD       reserved,
6319   IStorage  **ppstgOpen)
6320 {
6321   StorageBaseImpl* newStorage = 0;
6322   HANDLE       hFile      = INVALID_HANDLE_VALUE;
6323   HRESULT        hr         = STG_E_INVALIDFLAG;
6324   DWORD          shareMode;
6325   DWORD          accessMode;
6326   DWORD          creationMode;
6327   DWORD          fileAttributes;
6328   WCHAR          tempFileName[MAX_PATH];
6329
6330   TRACE("(%s, %x, %d, %p)\n",
6331         debugstr_w(pwcsName), grfMode,
6332         reserved, ppstgOpen);
6333
6334   if (ppstgOpen == 0)
6335     return STG_E_INVALIDPOINTER;
6336   if (reserved != 0)
6337     return STG_E_INVALIDPARAMETER;
6338
6339   /* if no share mode given then DENY_NONE is the default */
6340   if (STGM_SHARE_MODE(grfMode) == 0)
6341       grfMode |= STGM_SHARE_DENY_NONE;
6342
6343   if ( FAILED( validateSTGM(grfMode) ))
6344     goto end;
6345
6346   /* StgCreateDocFile seems to refuse readonly access, despite MSDN */
6347   switch(STGM_ACCESS_MODE(grfMode))
6348   {
6349   case STGM_WRITE:
6350   case STGM_READWRITE:
6351     break;
6352   default:
6353     goto end;
6354   }
6355
6356   /* in direct mode, can only use SHARE_EXCLUSIVE */
6357   if (!(grfMode & STGM_TRANSACTED) && (STGM_SHARE_MODE(grfMode) != STGM_SHARE_EXCLUSIVE))
6358     goto end;
6359
6360   /* but in transacted mode, any share mode is valid */
6361
6362   /*
6363    * Generate a unique name.
6364    */
6365   if (pwcsName == 0)
6366   {
6367     WCHAR tempPath[MAX_PATH];
6368     static const WCHAR prefix[] = { 'S', 'T', 'O', 0 };
6369
6370     memset(tempPath, 0, sizeof(tempPath));
6371     memset(tempFileName, 0, sizeof(tempFileName));
6372
6373     if ((GetTempPathW(MAX_PATH, tempPath)) == 0 )
6374       tempPath[0] = '.';
6375
6376     if (GetTempFileNameW(tempPath, prefix, 0, tempFileName) != 0)
6377       pwcsName = tempFileName;
6378     else
6379     {
6380       hr = STG_E_INSUFFICIENTMEMORY;
6381       goto end;
6382     }
6383
6384     creationMode = TRUNCATE_EXISTING;
6385   }
6386   else
6387   {
6388     creationMode = GetCreationModeFromSTGM(grfMode);
6389   }
6390
6391   /*
6392    * Interpret the STGM value grfMode
6393    */
6394   shareMode    = FILE_SHARE_READ | FILE_SHARE_WRITE;
6395   accessMode   = GetAccessModeFromSTGM(grfMode);
6396
6397   if (grfMode & STGM_DELETEONRELEASE)
6398     fileAttributes = FILE_FLAG_RANDOM_ACCESS | FILE_FLAG_DELETE_ON_CLOSE;
6399   else
6400     fileAttributes = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS;
6401
6402   if (STGM_SHARE_MODE(grfMode) && !(grfMode & STGM_SHARE_DENY_NONE))
6403   {
6404     static int fixme;
6405     if (!fixme++)
6406       FIXME("Storage share mode not implemented.\n");
6407   }
6408
6409   *ppstgOpen = 0;
6410
6411   hFile = CreateFileW(pwcsName,
6412                         accessMode,
6413                         shareMode,
6414                         NULL,
6415                         creationMode,
6416                         fileAttributes,
6417                         0);
6418
6419   if (hFile == INVALID_HANDLE_VALUE)
6420   {
6421     if(GetLastError() == ERROR_FILE_EXISTS)
6422       hr = STG_E_FILEALREADYEXISTS;
6423     else
6424       hr = E_FAIL;
6425     goto end;
6426   }
6427
6428   /*
6429    * Allocate and initialize the new IStorage32object.
6430    */
6431   hr = Storage_Construct(
6432          hFile,
6433         pwcsName,
6434          NULL,
6435          grfMode,
6436          TRUE,
6437          TRUE,
6438          &newStorage);
6439
6440   if (FAILED(hr))
6441   {
6442     goto end;
6443   }
6444
6445   /*
6446    * Get an "out" pointer for the caller.
6447    */
6448   *ppstgOpen = (IStorage*)newStorage;
6449
6450 end:
6451   TRACE("<-- %p  r = %08x\n", *ppstgOpen, hr);
6452
6453   return hr;
6454 }
6455
6456 /******************************************************************************
6457  *              StgCreateStorageEx        [OLE32.@]
6458  */
6459 HRESULT WINAPI StgCreateStorageEx(const WCHAR* pwcsName, DWORD grfMode, DWORD stgfmt, DWORD grfAttrs, STGOPTIONS* pStgOptions, void* reserved, REFIID riid, void** ppObjectOpen)
6460 {
6461     TRACE("(%s, %x, %x, %x, %p, %p, %p, %p)\n", debugstr_w(pwcsName),
6462           grfMode, stgfmt, grfAttrs, pStgOptions, reserved, riid, ppObjectOpen);
6463
6464     if (stgfmt != STGFMT_FILE && grfAttrs != 0)
6465     {
6466         ERR("grfAttrs must be 0 if stgfmt != STGFMT_FILE\n");
6467         return STG_E_INVALIDPARAMETER;
6468     }
6469
6470     if (stgfmt == STGFMT_FILE && grfAttrs != 0 && grfAttrs != FILE_FLAG_NO_BUFFERING)
6471     {
6472         ERR("grfAttrs must be 0 or FILE_FLAG_NO_BUFFERING if stgfmt == STGFMT_FILE\n");
6473         return STG_E_INVALIDPARAMETER;
6474     }
6475
6476     if (stgfmt == STGFMT_FILE)
6477     {
6478         ERR("Cannot use STGFMT_FILE - this is NTFS only\n");
6479         return STG_E_INVALIDPARAMETER;
6480     }
6481
6482     if (stgfmt == STGFMT_STORAGE || stgfmt == STGFMT_DOCFILE)
6483     {
6484         FIXME("Stub: calling StgCreateDocfile, but ignoring pStgOptions and grfAttrs\n");
6485         return StgCreateDocfile(pwcsName, grfMode, 0, (IStorage **)ppObjectOpen);
6486     }
6487
6488     ERR("Invalid stgfmt argument\n");
6489     return STG_E_INVALIDPARAMETER;
6490 }
6491
6492 /******************************************************************************
6493  *              StgCreatePropSetStg       [OLE32.@]
6494  */
6495 HRESULT WINAPI StgCreatePropSetStg(IStorage *pstg, DWORD reserved,
6496  IPropertySetStorage **ppPropSetStg)
6497 {
6498     HRESULT hr;
6499
6500     TRACE("(%p, 0x%x, %p)\n", pstg, reserved, ppPropSetStg);
6501     if (reserved)
6502         hr = STG_E_INVALIDPARAMETER;
6503     else
6504         hr = StorageBaseImpl_QueryInterface(pstg, &IID_IPropertySetStorage,
6505          (void**)ppPropSetStg);
6506     return hr;
6507 }
6508
6509 /******************************************************************************
6510  *              StgOpenStorageEx      [OLE32.@]
6511  */
6512 HRESULT WINAPI StgOpenStorageEx(const WCHAR* pwcsName, DWORD grfMode, DWORD stgfmt, DWORD grfAttrs, STGOPTIONS* pStgOptions, void* reserved, REFIID riid, void** ppObjectOpen)
6513 {
6514     TRACE("(%s, %x, %x, %x, %p, %p, %p, %p)\n", debugstr_w(pwcsName),
6515           grfMode, stgfmt, grfAttrs, pStgOptions, reserved, riid, ppObjectOpen);
6516
6517     if (stgfmt != STGFMT_DOCFILE && grfAttrs != 0)
6518     {
6519         ERR("grfAttrs must be 0 if stgfmt != STGFMT_DOCFILE\n");
6520         return STG_E_INVALIDPARAMETER;
6521     }
6522
6523     switch (stgfmt)
6524     {
6525     case STGFMT_FILE:
6526         ERR("Cannot use STGFMT_FILE - this is NTFS only\n");
6527         return STG_E_INVALIDPARAMETER;
6528
6529     case STGFMT_STORAGE:
6530         break;
6531
6532     case STGFMT_DOCFILE:
6533         if (grfAttrs && grfAttrs != FILE_FLAG_NO_BUFFERING)
6534         {
6535             ERR("grfAttrs must be 0 or FILE_FLAG_NO_BUFFERING if stgfmt == STGFMT_DOCFILE\n");
6536             return STG_E_INVALIDPARAMETER;
6537         }
6538         FIXME("Stub: calling StgOpenStorage, but ignoring pStgOptions and grfAttrs\n");
6539         break;
6540
6541     case STGFMT_ANY:
6542         WARN("STGFMT_ANY assuming storage\n");
6543         break;
6544
6545     default:
6546         return STG_E_INVALIDPARAMETER;
6547     }
6548
6549     return StgOpenStorage(pwcsName, NULL, grfMode, NULL, 0, (IStorage **)ppObjectOpen);
6550 }
6551
6552
6553 /******************************************************************************
6554  *              StgOpenStorage        [OLE32.@]
6555  */
6556 HRESULT WINAPI StgOpenStorage(
6557   const OLECHAR *pwcsName,
6558   IStorage      *pstgPriority,
6559   DWORD          grfMode,
6560   SNB            snbExclude,
6561   DWORD          reserved,
6562   IStorage     **ppstgOpen)
6563 {
6564   StorageBaseImpl* newStorage = 0;
6565   HRESULT        hr = S_OK;
6566   HANDLE         hFile = 0;
6567   DWORD          shareMode;
6568   DWORD          accessMode;
6569
6570   TRACE("(%s, %p, %x, %p, %d, %p)\n",
6571         debugstr_w(pwcsName), pstgPriority, grfMode,
6572         snbExclude, reserved, ppstgOpen);
6573
6574   if (pwcsName == 0)
6575   {
6576     hr = STG_E_INVALIDNAME;
6577     goto end;
6578   }
6579
6580   if (ppstgOpen == 0)
6581   {
6582     hr = STG_E_INVALIDPOINTER;
6583     goto end;
6584   }
6585
6586   if (reserved)
6587   {
6588     hr = STG_E_INVALIDPARAMETER;
6589     goto end;
6590   }
6591
6592   if (grfMode & STGM_PRIORITY)
6593   {
6594     if (grfMode & (STGM_TRANSACTED|STGM_SIMPLE|STGM_NOSCRATCH|STGM_NOSNAPSHOT))
6595       return STG_E_INVALIDFLAG;
6596     if (grfMode & STGM_DELETEONRELEASE)
6597       return STG_E_INVALIDFUNCTION;
6598     if(STGM_ACCESS_MODE(grfMode) != STGM_READ)
6599       return STG_E_INVALIDFLAG;
6600     grfMode &= ~0xf0; /* remove the existing sharing mode */
6601     grfMode |= STGM_SHARE_DENY_NONE;
6602
6603     /* STGM_PRIORITY stops other IStorage objects on the same file from
6604      * committing until the STGM_PRIORITY IStorage is closed. it also
6605      * stops non-transacted mode StgOpenStorage calls with write access from
6606      * succeeding. obviously, both of these cannot be achieved through just
6607      * file share flags */
6608     FIXME("STGM_PRIORITY mode not implemented correctly\n");
6609   }
6610
6611   /*
6612    * Validate the sharing mode
6613    */
6614   if (!(grfMode & (STGM_TRANSACTED|STGM_PRIORITY)))
6615     switch(STGM_SHARE_MODE(grfMode))
6616     {
6617       case STGM_SHARE_EXCLUSIVE:
6618       case STGM_SHARE_DENY_WRITE:
6619         break;
6620       default:
6621         hr = STG_E_INVALIDFLAG;
6622         goto end;
6623     }
6624
6625   if ( FAILED( validateSTGM(grfMode) ) ||
6626        (grfMode&STGM_CREATE))
6627   {
6628     hr = STG_E_INVALIDFLAG;
6629     goto end;
6630   }
6631
6632   /* shared reading requires transacted mode */
6633   if( STGM_SHARE_MODE(grfMode) == STGM_SHARE_DENY_WRITE &&
6634       STGM_ACCESS_MODE(grfMode) == STGM_READWRITE &&
6635      !(grfMode&STGM_TRANSACTED) )
6636   {
6637     hr = STG_E_INVALIDFLAG;
6638     goto end;
6639   }
6640
6641   /*
6642    * Interpret the STGM value grfMode
6643    */
6644   shareMode    = GetShareModeFromSTGM(grfMode);
6645   accessMode   = GetAccessModeFromSTGM(grfMode);
6646
6647   *ppstgOpen = 0;
6648
6649   hFile = CreateFileW( pwcsName,
6650                        accessMode,
6651                        shareMode,
6652                        NULL,
6653                        OPEN_EXISTING,
6654                        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
6655                        0);
6656
6657   if (hFile==INVALID_HANDLE_VALUE)
6658   {
6659     DWORD last_error = GetLastError();
6660
6661     hr = E_FAIL;
6662
6663     switch (last_error)
6664     {
6665       case ERROR_FILE_NOT_FOUND:
6666         hr = STG_E_FILENOTFOUND;
6667         break;
6668
6669       case ERROR_PATH_NOT_FOUND:
6670         hr = STG_E_PATHNOTFOUND;
6671         break;
6672
6673       case ERROR_ACCESS_DENIED:
6674       case ERROR_WRITE_PROTECT:
6675         hr = STG_E_ACCESSDENIED;
6676         break;
6677
6678       case ERROR_SHARING_VIOLATION:
6679         hr = STG_E_SHAREVIOLATION;
6680         break;
6681
6682       default:
6683         hr = E_FAIL;
6684     }
6685
6686     goto end;
6687   }
6688
6689   /*
6690    * Refuse to open the file if it's too small to be a structured storage file
6691    * FIXME: verify the file when reading instead of here
6692    */
6693   if (GetFileSize(hFile, NULL) < 0x100)
6694   {
6695     CloseHandle(hFile);
6696     hr = STG_E_FILEALREADYEXISTS;
6697     goto end;
6698   }
6699
6700   /*
6701    * Allocate and initialize the new IStorage32object.
6702    */
6703   hr = Storage_Construct(
6704          hFile,
6705          pwcsName,
6706          NULL,
6707          grfMode,
6708          TRUE,
6709          FALSE,
6710          &newStorage);
6711
6712   if (FAILED(hr))
6713   {
6714     /*
6715      * According to the docs if the file is not a storage, return STG_E_FILEALREADYEXISTS
6716      */
6717     if(hr == STG_E_INVALIDHEADER)
6718         hr = STG_E_FILEALREADYEXISTS;
6719     goto end;
6720   }
6721
6722   /*
6723    * Get an "out" pointer for the caller.
6724    */
6725   *ppstgOpen = (IStorage*)newStorage;
6726
6727 end:
6728   TRACE("<-- %08x, IStorage %p\n", hr, ppstgOpen ? *ppstgOpen : NULL);
6729   return hr;
6730 }
6731
6732 /******************************************************************************
6733  *    StgCreateDocfileOnILockBytes    [OLE32.@]
6734  */
6735 HRESULT WINAPI StgCreateDocfileOnILockBytes(
6736       ILockBytes *plkbyt,
6737       DWORD grfMode,
6738       DWORD reserved,
6739       IStorage** ppstgOpen)
6740 {
6741   StorageBaseImpl* newStorage = 0;
6742   HRESULT        hr         = S_OK;
6743
6744   if ((ppstgOpen == 0) || (plkbyt == 0))
6745     return STG_E_INVALIDPOINTER;
6746
6747   /*
6748    * Allocate and initialize the new IStorage object.
6749    */
6750   hr = Storage_Construct(
6751          0,
6752         0,
6753          plkbyt,
6754          grfMode,
6755          FALSE,
6756          TRUE,
6757          &newStorage);
6758
6759   if (FAILED(hr))
6760   {
6761     return hr;
6762   }
6763
6764   /*
6765    * Get an "out" pointer for the caller.
6766    */
6767   *ppstgOpen = (IStorage*)newStorage;
6768
6769   return hr;
6770 }
6771
6772 /******************************************************************************
6773  *    StgOpenStorageOnILockBytes    [OLE32.@]
6774  */
6775 HRESULT WINAPI StgOpenStorageOnILockBytes(
6776       ILockBytes *plkbyt,
6777       IStorage *pstgPriority,
6778       DWORD grfMode,
6779       SNB snbExclude,
6780       DWORD reserved,
6781       IStorage **ppstgOpen)
6782 {
6783   StorageBaseImpl* newStorage = 0;
6784   HRESULT        hr = S_OK;
6785
6786   if ((plkbyt == 0) || (ppstgOpen == 0))
6787     return STG_E_INVALIDPOINTER;
6788
6789   if ( FAILED( validateSTGM(grfMode) ))
6790     return STG_E_INVALIDFLAG;
6791
6792   *ppstgOpen = 0;
6793
6794   /*
6795    * Allocate and initialize the new IStorage object.
6796    */
6797   hr = Storage_Construct(
6798          0,
6799          0,
6800          plkbyt,
6801          grfMode,
6802          FALSE,
6803          FALSE,
6804          &newStorage);
6805
6806   if (FAILED(hr))
6807   {
6808     return hr;
6809   }
6810
6811   /*
6812    * Get an "out" pointer for the caller.
6813    */
6814   *ppstgOpen = (IStorage*)newStorage;
6815
6816   return hr;
6817 }
6818
6819 /******************************************************************************
6820  *              StgSetTimes [ole32.@]
6821  *              StgSetTimes [OLE32.@]
6822  *
6823  *
6824  */
6825 HRESULT WINAPI StgSetTimes(OLECHAR const *str, FILETIME const *pctime,
6826                            FILETIME const *patime, FILETIME const *pmtime)
6827 {
6828   IStorage *stg = NULL;
6829   HRESULT r;
6830
6831   TRACE("%s %p %p %p\n", debugstr_w(str), pctime, patime, pmtime);
6832
6833   r = StgOpenStorage(str, NULL, STGM_READWRITE | STGM_SHARE_DENY_WRITE,
6834                      0, 0, &stg);
6835   if( SUCCEEDED(r) )
6836   {
6837     r = IStorage_SetElementTimes(stg, NULL, pctime, patime, pmtime);
6838     IStorage_Release(stg);
6839   }
6840
6841   return r;
6842 }
6843
6844 /******************************************************************************
6845  *              StgIsStorageILockBytes        [OLE32.@]
6846  *
6847  * Determines if the ILockBytes contains a storage object.
6848  */
6849 HRESULT WINAPI StgIsStorageILockBytes(ILockBytes *plkbyt)
6850 {
6851   BYTE sig[8];
6852   ULARGE_INTEGER offset;
6853
6854   offset.u.HighPart = 0;
6855   offset.u.LowPart  = 0;
6856
6857   ILockBytes_ReadAt(plkbyt, offset, sig, sizeof(sig), NULL);
6858
6859   if (memcmp(sig, STORAGE_magic, sizeof(STORAGE_magic)) == 0)
6860     return S_OK;
6861
6862   return S_FALSE;
6863 }
6864
6865 /******************************************************************************
6866  *              WriteClassStg        [OLE32.@]
6867  *
6868  * This method will store the specified CLSID in the specified storage object
6869  */
6870 HRESULT WINAPI WriteClassStg(IStorage* pStg, REFCLSID rclsid)
6871 {
6872   HRESULT hRes;
6873
6874   if(!pStg)
6875     return E_INVALIDARG;
6876
6877   if(!rclsid)
6878     return STG_E_INVALIDPOINTER;
6879
6880   hRes = IStorage_SetClass(pStg, rclsid);
6881
6882   return hRes;
6883 }
6884
6885 /***********************************************************************
6886  *    ReadClassStg (OLE32.@)
6887  *
6888  * This method reads the CLSID previously written to a storage object with
6889  * the WriteClassStg.
6890  *
6891  * PARAMS
6892  *  pstg    [I] IStorage pointer
6893  *  pclsid  [O] Pointer to where the CLSID is written
6894  *
6895  * RETURNS
6896  *  Success: S_OK.
6897  *  Failure: HRESULT code.
6898  */
6899 HRESULT WINAPI ReadClassStg(IStorage *pstg,CLSID *pclsid){
6900
6901     STATSTG pstatstg;
6902     HRESULT hRes;
6903
6904     TRACE("(%p, %p)\n", pstg, pclsid);
6905
6906     if(!pstg || !pclsid)
6907         return E_INVALIDARG;
6908
6909    /*
6910     * read a STATSTG structure (contains the clsid) from the storage
6911     */
6912     hRes=IStorage_Stat(pstg,&pstatstg,STATFLAG_NONAME);
6913
6914     if(SUCCEEDED(hRes))
6915         *pclsid=pstatstg.clsid;
6916
6917     return hRes;
6918 }
6919
6920 /***********************************************************************
6921  *    OleLoadFromStream (OLE32.@)
6922  *
6923  * This function loads an object from stream
6924  */
6925 HRESULT  WINAPI OleLoadFromStream(IStream *pStm,REFIID iidInterface,void** ppvObj)
6926 {
6927     CLSID       clsid;
6928     HRESULT     res;
6929     LPPERSISTSTREAM     xstm;
6930
6931     TRACE("(%p,%s,%p)\n",pStm,debugstr_guid(iidInterface),ppvObj);
6932
6933     res=ReadClassStm(pStm,&clsid);
6934     if (FAILED(res))
6935         return res;
6936     res=CoCreateInstance(&clsid,NULL,CLSCTX_INPROC_SERVER,iidInterface,ppvObj);
6937     if (FAILED(res))
6938         return res;
6939     res=IUnknown_QueryInterface((IUnknown*)*ppvObj,&IID_IPersistStream,(LPVOID*)&xstm);
6940     if (FAILED(res)) {
6941         IUnknown_Release((IUnknown*)*ppvObj);
6942         return res;
6943     }
6944     res=IPersistStream_Load(xstm,pStm);
6945     IPersistStream_Release(xstm);
6946     /* FIXME: all refcounts ok at this point? I think they should be:
6947      *          pStm    : unchanged
6948      *          ppvObj  : 1
6949      *          xstm    : 0 (released)
6950      */
6951     return res;
6952 }
6953
6954 /***********************************************************************
6955  *    OleSaveToStream (OLE32.@)
6956  *
6957  * This function saves an object with the IPersistStream interface on it
6958  * to the specified stream.
6959  */
6960 HRESULT  WINAPI OleSaveToStream(IPersistStream *pPStm,IStream *pStm)
6961 {
6962
6963     CLSID clsid;
6964     HRESULT res;
6965
6966     TRACE("(%p,%p)\n",pPStm,pStm);
6967
6968     res=IPersistStream_GetClassID(pPStm,&clsid);
6969
6970     if (SUCCEEDED(res)){
6971
6972         res=WriteClassStm(pStm,&clsid);
6973
6974         if (SUCCEEDED(res))
6975
6976             res=IPersistStream_Save(pPStm,pStm,TRUE);
6977     }
6978
6979     TRACE("Finished Save\n");
6980     return res;
6981 }
6982
6983 /****************************************************************************
6984  * This method validate a STGM parameter that can contain the values below
6985  *
6986  * The stgm modes in 0x0000ffff are not bit masks, but distinct 4 bit values.
6987  * The stgm values contained in 0xffff0000 are bitmasks.
6988  *
6989  * STGM_DIRECT               0x00000000
6990  * STGM_TRANSACTED           0x00010000
6991  * STGM_SIMPLE               0x08000000
6992  *
6993  * STGM_READ                 0x00000000
6994  * STGM_WRITE                0x00000001
6995  * STGM_READWRITE            0x00000002
6996  *
6997  * STGM_SHARE_DENY_NONE      0x00000040
6998  * STGM_SHARE_DENY_READ      0x00000030
6999  * STGM_SHARE_DENY_WRITE     0x00000020
7000  * STGM_SHARE_EXCLUSIVE      0x00000010
7001  *
7002  * STGM_PRIORITY             0x00040000
7003  * STGM_DELETEONRELEASE      0x04000000
7004  *
7005  * STGM_CREATE               0x00001000
7006  * STGM_CONVERT              0x00020000
7007  * STGM_FAILIFTHERE          0x00000000
7008  *
7009  * STGM_NOSCRATCH            0x00100000
7010  * STGM_NOSNAPSHOT           0x00200000
7011  */
7012 static HRESULT validateSTGM(DWORD stgm)
7013 {
7014   DWORD access = STGM_ACCESS_MODE(stgm);
7015   DWORD share  = STGM_SHARE_MODE(stgm);
7016   DWORD create = STGM_CREATE_MODE(stgm);
7017
7018   if (stgm&~STGM_KNOWN_FLAGS)
7019   {
7020     ERR("unknown flags %08x\n", stgm);
7021     return E_FAIL;
7022   }
7023
7024   switch (access)
7025   {
7026   case STGM_READ:
7027   case STGM_WRITE:
7028   case STGM_READWRITE:
7029     break;
7030   default:
7031     return E_FAIL;
7032   }
7033
7034   switch (share)
7035   {
7036   case STGM_SHARE_DENY_NONE:
7037   case STGM_SHARE_DENY_READ:
7038   case STGM_SHARE_DENY_WRITE:
7039   case STGM_SHARE_EXCLUSIVE:
7040     break;
7041   default:
7042     return E_FAIL;
7043   }
7044
7045   switch (create)
7046   {
7047   case STGM_CREATE:
7048   case STGM_FAILIFTHERE:
7049     break;
7050   default:
7051     return E_FAIL;
7052   }
7053
7054   /*
7055    * STGM_DIRECT | STGM_TRANSACTED | STGM_SIMPLE
7056    */
7057   if ( (stgm & STGM_TRANSACTED) && (stgm & STGM_SIMPLE) )
7058       return E_FAIL;
7059
7060   /*
7061    * STGM_CREATE | STGM_CONVERT
7062    * if both are false, STGM_FAILIFTHERE is set to TRUE
7063    */
7064   if ( create == STGM_CREATE && (stgm & STGM_CONVERT) )
7065     return E_FAIL;
7066
7067   /*
7068    * STGM_NOSCRATCH requires STGM_TRANSACTED
7069    */
7070   if ( (stgm & STGM_NOSCRATCH) && !(stgm & STGM_TRANSACTED) )
7071     return E_FAIL;
7072
7073   /*
7074    * STGM_NOSNAPSHOT requires STGM_TRANSACTED and
7075    * not STGM_SHARE_EXCLUSIVE or STGM_SHARE_DENY_WRITE`
7076    */
7077   if ( (stgm & STGM_NOSNAPSHOT) &&
7078         (!(stgm & STGM_TRANSACTED) ||
7079          share == STGM_SHARE_EXCLUSIVE ||
7080          share == STGM_SHARE_DENY_WRITE) )
7081     return E_FAIL;
7082
7083   return S_OK;
7084 }
7085
7086 /****************************************************************************
7087  *      GetShareModeFromSTGM
7088  *
7089  * This method will return a share mode flag from a STGM value.
7090  * The STGM value is assumed valid.
7091  */
7092 static DWORD GetShareModeFromSTGM(DWORD stgm)
7093 {
7094   switch (STGM_SHARE_MODE(stgm))
7095   {
7096   case STGM_SHARE_DENY_NONE:
7097     return FILE_SHARE_READ | FILE_SHARE_WRITE;
7098   case STGM_SHARE_DENY_READ:
7099     return FILE_SHARE_WRITE;
7100   case STGM_SHARE_DENY_WRITE:
7101     return FILE_SHARE_READ;
7102   case STGM_SHARE_EXCLUSIVE:
7103     return 0;
7104   }
7105   ERR("Invalid share mode!\n");
7106   assert(0);
7107   return 0;
7108 }
7109
7110 /****************************************************************************
7111  *      GetAccessModeFromSTGM
7112  *
7113  * This method will return an access mode flag from a STGM value.
7114  * The STGM value is assumed valid.
7115  */
7116 static DWORD GetAccessModeFromSTGM(DWORD stgm)
7117 {
7118   switch (STGM_ACCESS_MODE(stgm))
7119   {
7120   case STGM_READ:
7121     return GENERIC_READ;
7122   case STGM_WRITE:
7123   case STGM_READWRITE:
7124     return GENERIC_READ | GENERIC_WRITE;
7125   }
7126   ERR("Invalid access mode!\n");
7127   assert(0);
7128   return 0;
7129 }
7130
7131 /****************************************************************************
7132  *      GetCreationModeFromSTGM
7133  *
7134  * This method will return a creation mode flag from a STGM value.
7135  * The STGM value is assumed valid.
7136  */
7137 static DWORD GetCreationModeFromSTGM(DWORD stgm)
7138 {
7139   switch(STGM_CREATE_MODE(stgm))
7140   {
7141   case STGM_CREATE:
7142     return CREATE_ALWAYS;
7143   case STGM_CONVERT:
7144     FIXME("STGM_CONVERT not implemented!\n");
7145     return CREATE_NEW;
7146   case STGM_FAILIFTHERE:
7147     return CREATE_NEW;
7148   }
7149   ERR("Invalid create mode!\n");
7150   assert(0);
7151   return 0;
7152 }
7153
7154
7155 /*************************************************************************
7156  * OLECONVERT_LoadOLE10 [Internal]
7157  *
7158  * Loads the OLE10 STREAM to memory
7159  *
7160  * PARAMS
7161  *     pOleStream   [I] The OLESTREAM
7162  *     pData        [I] Data Structure for the OLESTREAM Data
7163  *
7164  * RETURNS
7165  *     Success:  S_OK
7166  *     Failure:  CONVERT10_E_OLESTREAM_GET for invalid Get
7167  *               CONVERT10_E_OLESTREAM_FMT if the OLEID is invalid
7168  *
7169  * NOTES
7170  *     This function is used by OleConvertOLESTREAMToIStorage only.
7171  *
7172  *     Memory allocated for pData must be freed by the caller
7173  */
7174 static HRESULT OLECONVERT_LoadOLE10(LPOLESTREAM pOleStream, OLECONVERT_OLESTREAM_DATA *pData, BOOL bStrem1)
7175 {
7176         DWORD dwSize;
7177         HRESULT hRes = S_OK;
7178         int nTryCnt=0;
7179         int max_try = 6;
7180
7181         pData->pData = NULL;
7182         pData->pstrOleObjFileName = NULL;
7183
7184         for( nTryCnt=0;nTryCnt < max_try; nTryCnt++)
7185         {
7186         /* Get the OleID */
7187         dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)&(pData->dwOleID), sizeof(pData->dwOleID));
7188         if(dwSize != sizeof(pData->dwOleID))
7189         {
7190                 hRes = CONVERT10_E_OLESTREAM_GET;
7191         }
7192         else if(pData->dwOleID != OLESTREAM_ID)
7193         {
7194                 hRes = CONVERT10_E_OLESTREAM_FMT;
7195         }
7196                 else
7197                 {
7198                         hRes = S_OK;
7199                         break;
7200                 }
7201         }
7202
7203         if(hRes == S_OK)
7204         {
7205                 /* Get the TypeID... more info needed for this field */
7206                 dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)&(pData->dwTypeID), sizeof(pData->dwTypeID));
7207                 if(dwSize != sizeof(pData->dwTypeID))
7208                 {
7209                         hRes = CONVERT10_E_OLESTREAM_GET;
7210                 }
7211         }
7212         if(hRes == S_OK)
7213         {
7214                 if(pData->dwTypeID != 0)
7215                 {
7216                         /* Get the length of the OleTypeName */
7217                         dwSize = pOleStream->lpstbl->Get(pOleStream, (void *) &(pData->dwOleTypeNameLength), sizeof(pData->dwOleTypeNameLength));
7218                         if(dwSize != sizeof(pData->dwOleTypeNameLength))
7219                         {
7220                                 hRes = CONVERT10_E_OLESTREAM_GET;
7221                         }
7222
7223                         if(hRes == S_OK)
7224                         {
7225                                 if(pData->dwOleTypeNameLength > 0)
7226                                 {
7227                                         /* Get the OleTypeName */
7228                                         dwSize = pOleStream->lpstbl->Get(pOleStream, pData->strOleTypeName, pData->dwOleTypeNameLength);
7229                                         if(dwSize != pData->dwOleTypeNameLength)
7230                                         {
7231                                                 hRes = CONVERT10_E_OLESTREAM_GET;
7232                                         }
7233                                 }
7234                         }
7235                         if(bStrem1)
7236                         {
7237                                 dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)&(pData->dwOleObjFileNameLength), sizeof(pData->dwOleObjFileNameLength));
7238                                 if(dwSize != sizeof(pData->dwOleObjFileNameLength))
7239                                 {
7240                                         hRes = CONVERT10_E_OLESTREAM_GET;
7241                                 }
7242                         if(hRes == S_OK)
7243                         {
7244                                         if(pData->dwOleObjFileNameLength < 1) /* there is no file name exist */
7245                                                 pData->dwOleObjFileNameLength = sizeof(pData->dwOleObjFileNameLength);
7246                                         pData->pstrOleObjFileName = HeapAlloc(GetProcessHeap(), 0, pData->dwOleObjFileNameLength);
7247                                         if(pData->pstrOleObjFileName)
7248                                         {
7249                                                 dwSize = pOleStream->lpstbl->Get(pOleStream, pData->pstrOleObjFileName, pData->dwOleObjFileNameLength);
7250                                                 if(dwSize != pData->dwOleObjFileNameLength)
7251                                                 {
7252                                                         hRes = CONVERT10_E_OLESTREAM_GET;
7253                                                 }
7254                                         }
7255                                         else
7256                                                 hRes = CONVERT10_E_OLESTREAM_GET;
7257                                 }
7258                         }
7259                         else
7260                         {
7261                                 /* Get the Width of the Metafile */
7262                                 dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)&(pData->dwMetaFileWidth), sizeof(pData->dwMetaFileWidth));
7263                                 if(dwSize != sizeof(pData->dwMetaFileWidth))
7264                                 {
7265                                         hRes = CONVERT10_E_OLESTREAM_GET;
7266                                 }
7267                         if(hRes == S_OK)
7268                         {
7269                                 /* Get the Height of the Metafile */
7270                                 dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)&(pData->dwMetaFileHeight), sizeof(pData->dwMetaFileHeight));
7271                                 if(dwSize != sizeof(pData->dwMetaFileHeight))
7272                                 {
7273                                         hRes = CONVERT10_E_OLESTREAM_GET;
7274                                 }
7275                         }
7276                         }
7277                         if(hRes == S_OK)
7278                         {
7279                                 /* Get the Length of the Data */
7280                                 dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)&(pData->dwDataLength), sizeof(pData->dwDataLength));
7281                                 if(dwSize != sizeof(pData->dwDataLength))
7282                                 {
7283                                         hRes = CONVERT10_E_OLESTREAM_GET;
7284                                 }
7285                         }
7286
7287                         if(hRes == S_OK) /* I don't know what this 8 byte information is. We have to figure out */
7288                         {
7289                                 if(!bStrem1) /* if it is a second OLE stream data */
7290                                 {
7291                                         pData->dwDataLength -= 8;
7292                                         dwSize = pOleStream->lpstbl->Get(pOleStream, pData->strUnknown, sizeof(pData->strUnknown));
7293                                         if(dwSize != sizeof(pData->strUnknown))
7294                                         {
7295                                                 hRes = CONVERT10_E_OLESTREAM_GET;
7296                                         }
7297                                 }
7298                         }
7299                         if(hRes == S_OK)
7300                         {
7301                                 if(pData->dwDataLength > 0)
7302                                 {
7303                                         pData->pData = HeapAlloc(GetProcessHeap(),0,pData->dwDataLength);
7304
7305                                         /* Get Data (ex. IStorage, Metafile, or BMP) */
7306                                         if(pData->pData)
7307                                         {
7308                                                 dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)pData->pData, pData->dwDataLength);
7309                                                 if(dwSize != pData->dwDataLength)
7310                                                 {
7311                                                         hRes = CONVERT10_E_OLESTREAM_GET;
7312                                                 }
7313                                         }
7314                                         else
7315                                         {
7316                                                 hRes = CONVERT10_E_OLESTREAM_GET;
7317                                         }
7318                                 }
7319                         }
7320                 }
7321         }
7322         return hRes;
7323 }
7324
7325 /*************************************************************************
7326  * OLECONVERT_SaveOLE10 [Internal]
7327  *
7328  * Saves the OLE10 STREAM From memory
7329  *
7330  * PARAMS
7331  *     pData        [I] Data Structure for the OLESTREAM Data
7332  *     pOleStream   [I] The OLESTREAM to save
7333  *
7334  * RETURNS
7335  *     Success:  S_OK
7336  *     Failure:  CONVERT10_E_OLESTREAM_PUT for invalid Put
7337  *
7338  * NOTES
7339  *     This function is used by OleConvertIStorageToOLESTREAM only.
7340  *
7341  */
7342 static HRESULT OLECONVERT_SaveOLE10(OLECONVERT_OLESTREAM_DATA *pData, LPOLESTREAM pOleStream)
7343 {
7344     DWORD dwSize;
7345     HRESULT hRes = S_OK;
7346
7347
7348    /* Set the OleID */
7349     dwSize = pOleStream->lpstbl->Put(pOleStream, (void *)&(pData->dwOleID), sizeof(pData->dwOleID));
7350     if(dwSize != sizeof(pData->dwOleID))
7351     {
7352         hRes = CONVERT10_E_OLESTREAM_PUT;
7353     }
7354
7355     if(hRes == S_OK)
7356     {
7357         /* Set the TypeID */
7358         dwSize = pOleStream->lpstbl->Put(pOleStream, (void *)&(pData->dwTypeID), sizeof(pData->dwTypeID));
7359         if(dwSize != sizeof(pData->dwTypeID))
7360         {
7361             hRes = CONVERT10_E_OLESTREAM_PUT;
7362         }
7363     }
7364
7365     if(pData->dwOleID == OLESTREAM_ID && pData->dwTypeID != 0 && hRes == S_OK)
7366     {
7367         /* Set the Length of the OleTypeName */
7368         dwSize = pOleStream->lpstbl->Put(pOleStream, (void *)&(pData->dwOleTypeNameLength), sizeof(pData->dwOleTypeNameLength));
7369         if(dwSize != sizeof(pData->dwOleTypeNameLength))
7370         {
7371             hRes = CONVERT10_E_OLESTREAM_PUT;
7372         }
7373
7374         if(hRes == S_OK)
7375         {
7376             if(pData->dwOleTypeNameLength > 0)
7377             {
7378                 /* Set the OleTypeName */
7379                 dwSize = pOleStream->lpstbl->Put(pOleStream, pData->strOleTypeName, pData->dwOleTypeNameLength);
7380                 if(dwSize != pData->dwOleTypeNameLength)
7381                 {
7382                     hRes = CONVERT10_E_OLESTREAM_PUT;
7383                 }
7384             }
7385         }
7386
7387         if(hRes == S_OK)
7388         {
7389             /* Set the width of the Metafile */
7390             dwSize = pOleStream->lpstbl->Put(pOleStream, (void *)&(pData->dwMetaFileWidth), sizeof(pData->dwMetaFileWidth));
7391             if(dwSize != sizeof(pData->dwMetaFileWidth))
7392             {
7393                 hRes = CONVERT10_E_OLESTREAM_PUT;
7394             }
7395         }
7396
7397         if(hRes == S_OK)
7398         {
7399             /* Set the height of the Metafile */
7400             dwSize = pOleStream->lpstbl->Put(pOleStream, (void *)&(pData->dwMetaFileHeight), sizeof(pData->dwMetaFileHeight));
7401             if(dwSize != sizeof(pData->dwMetaFileHeight))
7402             {
7403                 hRes = CONVERT10_E_OLESTREAM_PUT;
7404             }
7405         }
7406
7407         if(hRes == S_OK)
7408         {
7409             /* Set the length of the Data */
7410             dwSize = pOleStream->lpstbl->Put(pOleStream, (void *)&(pData->dwDataLength), sizeof(pData->dwDataLength));
7411             if(dwSize != sizeof(pData->dwDataLength))
7412             {
7413                 hRes = CONVERT10_E_OLESTREAM_PUT;
7414             }
7415         }
7416
7417         if(hRes == S_OK)
7418         {
7419             if(pData->dwDataLength > 0)
7420             {
7421                 /* Set the Data (eg. IStorage, Metafile, Bitmap) */
7422                 dwSize = pOleStream->lpstbl->Put(pOleStream, (void *)  pData->pData, pData->dwDataLength);
7423                 if(dwSize != pData->dwDataLength)
7424                 {
7425                     hRes = CONVERT10_E_OLESTREAM_PUT;
7426                 }
7427             }
7428         }
7429     }
7430     return hRes;
7431 }
7432
7433 /*************************************************************************
7434  * OLECONVERT_GetOLE20FromOLE10[Internal]
7435  *
7436  * This function copies OLE10 Data (the IStorage in the OLESTREAM) to disk,
7437  * opens it, and copies the content to the dest IStorage for
7438  * OleConvertOLESTREAMToIStorage
7439  *
7440  *
7441  * PARAMS
7442  *     pDestStorage  [I] The IStorage to copy the data to
7443  *     pBuffer       [I] Buffer that contains the IStorage from the OLESTREAM
7444  *     nBufferLength [I] The size of the buffer
7445  *
7446  * RETURNS
7447  *     Nothing
7448  *
7449  * NOTES
7450  *
7451  *
7452  */
7453 static void OLECONVERT_GetOLE20FromOLE10(LPSTORAGE pDestStorage, const BYTE *pBuffer, DWORD nBufferLength)
7454 {
7455     HRESULT hRes;
7456     HANDLE hFile;
7457     IStorage *pTempStorage;
7458     DWORD dwNumOfBytesWritten;
7459     WCHAR wstrTempDir[MAX_PATH], wstrTempFile[MAX_PATH];
7460     static const WCHAR wstrPrefix[] = {'s', 'i', 's', 0};
7461
7462     /* Create a temp File */
7463     GetTempPathW(MAX_PATH, wstrTempDir);
7464     GetTempFileNameW(wstrTempDir, wstrPrefix, 0, wstrTempFile);
7465     hFile = CreateFileW(wstrTempFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
7466
7467     if(hFile != INVALID_HANDLE_VALUE)
7468     {
7469         /* Write IStorage Data to File */
7470         WriteFile(hFile, pBuffer, nBufferLength, &dwNumOfBytesWritten, NULL);
7471         CloseHandle(hFile);
7472
7473         /* Open and copy temp storage to the Dest Storage */
7474         hRes = StgOpenStorage(wstrTempFile, NULL, STGM_READ, NULL, 0, &pTempStorage);
7475         if(hRes == S_OK)
7476         {
7477             hRes = IStorage_CopyTo(pTempStorage, 0, NULL, NULL, pDestStorage);
7478             IStorage_Release(pTempStorage);
7479         }
7480         DeleteFileW(wstrTempFile);
7481     }
7482 }
7483
7484
7485 /*************************************************************************
7486  * OLECONVERT_WriteOLE20ToBuffer [Internal]
7487  *
7488  * Saves the OLE10 STREAM From memory
7489  *
7490  * PARAMS
7491  *     pStorage  [I] The Src IStorage to copy
7492  *     pData     [I] The Dest Memory to write to.
7493  *
7494  * RETURNS
7495  *     The size in bytes allocated for pData
7496  *
7497  * NOTES
7498  *     Memory allocated for pData must be freed by the caller
7499  *
7500  *     Used by OleConvertIStorageToOLESTREAM only.
7501  *
7502  */
7503 static DWORD OLECONVERT_WriteOLE20ToBuffer(LPSTORAGE pStorage, BYTE **pData)
7504 {
7505     HANDLE hFile;
7506     HRESULT hRes;
7507     DWORD nDataLength = 0;
7508     IStorage *pTempStorage;
7509     WCHAR wstrTempDir[MAX_PATH], wstrTempFile[MAX_PATH];
7510     static const WCHAR wstrPrefix[] = {'s', 'i', 's', 0};
7511
7512     *pData = NULL;
7513
7514     /* Create temp Storage */
7515     GetTempPathW(MAX_PATH, wstrTempDir);
7516     GetTempFileNameW(wstrTempDir, wstrPrefix, 0, wstrTempFile);
7517     hRes = StgCreateDocfile(wstrTempFile, STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &pTempStorage);
7518
7519     if(hRes == S_OK)
7520     {
7521         /* Copy Src Storage to the Temp Storage */
7522         IStorage_CopyTo(pStorage, 0, NULL, NULL, pTempStorage);
7523         IStorage_Release(pTempStorage);
7524
7525         /* Open Temp Storage as a file and copy to memory */
7526         hFile = CreateFileW(wstrTempFile, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
7527         if(hFile != INVALID_HANDLE_VALUE)
7528         {
7529             nDataLength = GetFileSize(hFile, NULL);
7530             *pData = HeapAlloc(GetProcessHeap(),0,nDataLength);
7531             ReadFile(hFile, *pData, nDataLength, &nDataLength, 0);
7532             CloseHandle(hFile);
7533         }
7534         DeleteFileW(wstrTempFile);
7535     }
7536     return nDataLength;
7537 }
7538
7539 /*************************************************************************
7540  * OLECONVERT_CreateOleStream [Internal]
7541  *
7542  * Creates the "\001OLE" stream in the IStorage if necessary.
7543  *
7544  * PARAMS
7545  *     pStorage     [I] Dest storage to create the stream in
7546  *
7547  * RETURNS
7548  *     Nothing
7549  *
7550  * NOTES
7551  *     This function is used by OleConvertOLESTREAMToIStorage only.
7552  *
7553  *     This stream is still unknown, MS Word seems to have extra data
7554  *     but since the data is stored in the OLESTREAM there should be
7555  *     no need to recreate the stream.  If the stream is manually
7556  *     deleted it will create it with this default data.
7557  *
7558  */
7559 void OLECONVERT_CreateOleStream(LPSTORAGE pStorage)
7560 {
7561     HRESULT hRes;
7562     IStream *pStream;
7563     static const WCHAR wstrStreamName[] = {1,'O', 'l', 'e', 0};
7564     BYTE pOleStreamHeader [] =
7565     {
7566         0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
7567         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7568         0x00, 0x00, 0x00, 0x00
7569     };
7570
7571     /* Create stream if not present */
7572     hRes = IStorage_CreateStream(pStorage, wstrStreamName,
7573         STGM_WRITE  | STGM_SHARE_EXCLUSIVE, 0, 0, &pStream );
7574
7575     if(hRes == S_OK)
7576     {
7577         /* Write default Data */
7578         hRes = IStream_Write(pStream, pOleStreamHeader, sizeof(pOleStreamHeader), NULL);
7579         IStream_Release(pStream);
7580     }
7581 }
7582
7583 /* write a string to a stream, preceded by its length */
7584 static HRESULT STREAM_WriteString( IStream *stm, LPCWSTR string )
7585 {
7586     HRESULT r;
7587     LPSTR str;
7588     DWORD len = 0;
7589
7590     if( string )
7591         len = WideCharToMultiByte( CP_ACP, 0, string, -1, NULL, 0, NULL, NULL);
7592     r = IStream_Write( stm, &len, sizeof(len), NULL);
7593     if( FAILED( r ) )
7594         return r;
7595     if(len == 0)
7596         return r;
7597     str = CoTaskMemAlloc( len );
7598     WideCharToMultiByte( CP_ACP, 0, string, -1, str, len, NULL, NULL);
7599     r = IStream_Write( stm, str, len, NULL);
7600     CoTaskMemFree( str );
7601     return r;
7602 }
7603
7604 /* read a string preceded by its length from a stream */
7605 static HRESULT STREAM_ReadString( IStream *stm, LPWSTR *string )
7606 {
7607     HRESULT r;
7608     DWORD len, count = 0;
7609     LPSTR str;
7610     LPWSTR wstr;
7611
7612     r = IStream_Read( stm, &len, sizeof(len), &count );
7613     if( FAILED( r ) )
7614         return r;
7615     if( count != sizeof(len) )
7616         return E_OUTOFMEMORY;
7617
7618     TRACE("%d bytes\n",len);
7619
7620     str = CoTaskMemAlloc( len );
7621     if( !str )
7622         return E_OUTOFMEMORY;
7623     count = 0;
7624     r = IStream_Read( stm, str, len, &count );
7625     if( FAILED( r ) )
7626         return r;
7627     if( count != len )
7628     {
7629         CoTaskMemFree( str );
7630         return E_OUTOFMEMORY;
7631     }
7632
7633     TRACE("Read string %s\n",debugstr_an(str,len));
7634
7635     len = MultiByteToWideChar( CP_ACP, 0, str, count, NULL, 0 );
7636     wstr = CoTaskMemAlloc( (len + 1)*sizeof (WCHAR) );
7637     if( wstr )
7638          MultiByteToWideChar( CP_ACP, 0, str, count, wstr, len );
7639     CoTaskMemFree( str );
7640
7641     *string = wstr;
7642
7643     return r;
7644 }
7645
7646
7647 static HRESULT STORAGE_WriteCompObj( LPSTORAGE pstg, CLSID *clsid,
7648     LPCWSTR lpszUserType, LPCWSTR szClipName, LPCWSTR szProgIDName )
7649 {
7650     IStream *pstm;
7651     HRESULT r = S_OK;
7652     static const WCHAR szwStreamName[] = {1, 'C', 'o', 'm', 'p', 'O', 'b', 'j', 0};
7653
7654     static const BYTE unknown1[12] =
7655        { 0x01, 0x00, 0xFE, 0xFF, 0x03, 0x0A, 0x00, 0x00,
7656          0xFF, 0xFF, 0xFF, 0xFF};
7657     static const BYTE unknown2[16] =
7658        { 0xF4, 0x39, 0xB2, 0x71, 0x00, 0x00, 0x00, 0x00,
7659          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
7660
7661     TRACE("%p %s %s %s %s\n", pstg, debugstr_guid(clsid),
7662            debugstr_w(lpszUserType), debugstr_w(szClipName),
7663            debugstr_w(szProgIDName));
7664
7665     /*  Create a CompObj stream */
7666     r = IStorage_CreateStream(pstg, szwStreamName,
7667         STGM_CREATE | STGM_WRITE  | STGM_SHARE_EXCLUSIVE, 0, 0, &pstm );
7668     if( FAILED (r) )
7669         return r;
7670
7671     /* Write CompObj Structure to stream */
7672     r = IStream_Write(pstm, unknown1, sizeof(unknown1), NULL);
7673
7674     if( SUCCEEDED( r ) )
7675         r = WriteClassStm( pstm, clsid );
7676
7677     if( SUCCEEDED( r ) )
7678         r = STREAM_WriteString( pstm, lpszUserType );
7679     if( SUCCEEDED( r ) )
7680         r = STREAM_WriteString( pstm, szClipName );
7681     if( SUCCEEDED( r ) )
7682         r = STREAM_WriteString( pstm, szProgIDName );
7683     if( SUCCEEDED( r ) )
7684         r = IStream_Write(pstm, unknown2, sizeof(unknown2), NULL);
7685
7686     IStream_Release( pstm );
7687
7688     return r;
7689 }
7690
7691 /***********************************************************************
7692  *               WriteFmtUserTypeStg (OLE32.@)
7693  */
7694 HRESULT WINAPI WriteFmtUserTypeStg(
7695           LPSTORAGE pstg, CLIPFORMAT cf, LPOLESTR lpszUserType)
7696 {
7697     HRESULT r;
7698     WCHAR szwClipName[0x40];
7699     CLSID clsid = CLSID_NULL;
7700     LPWSTR wstrProgID = NULL;
7701     DWORD n;
7702
7703     TRACE("(%p,%x,%s)\n",pstg,cf,debugstr_w(lpszUserType));
7704
7705     /* get the clipboard format name */
7706     n = GetClipboardFormatNameW( cf, szwClipName, sizeof(szwClipName)/sizeof(szwClipName[0]) );
7707     szwClipName[n]=0;
7708
7709     TRACE("Clipboard name is %s\n", debugstr_w(szwClipName));
7710
7711     /* FIXME: There's room to save a CLSID and its ProgID, but
7712        the CLSID is not looked up in the registry and in all the
7713        tests I wrote it was CLSID_NULL.  Where does it come from?
7714     */
7715
7716     /* get the real program ID.  This may fail, but that's fine */
7717     ProgIDFromCLSID(&clsid, &wstrProgID);
7718
7719     TRACE("progid is %s\n",debugstr_w(wstrProgID));
7720
7721     r = STORAGE_WriteCompObj( pstg, &clsid,
7722                               lpszUserType, szwClipName, wstrProgID );
7723
7724     CoTaskMemFree(wstrProgID);
7725
7726     return r;
7727 }
7728
7729
7730 /******************************************************************************
7731  *              ReadFmtUserTypeStg        [OLE32.@]
7732  */
7733 HRESULT WINAPI ReadFmtUserTypeStg (LPSTORAGE pstg, CLIPFORMAT* pcf, LPOLESTR* lplpszUserType)
7734 {
7735     HRESULT r;
7736     IStream *stm = 0;
7737     static const WCHAR szCompObj[] = { 1, 'C','o','m','p','O','b','j', 0 };
7738     unsigned char unknown1[12];
7739     unsigned char unknown2[16];
7740     DWORD count;
7741     LPWSTR szProgIDName = NULL, szCLSIDName = NULL, szOleTypeName = NULL;
7742     CLSID clsid;
7743
7744     TRACE("(%p,%p,%p)\n", pstg, pcf, lplpszUserType);
7745
7746     r = IStorage_OpenStream( pstg, szCompObj, NULL,
7747                     STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm );
7748     if( FAILED ( r ) )
7749     {
7750         WARN("Failed to open stream r = %08x\n", r);
7751         return r;
7752     }
7753
7754     /* read the various parts of the structure */
7755     r = IStream_Read( stm, unknown1, sizeof(unknown1), &count );
7756     if( FAILED( r ) || ( count != sizeof(unknown1) ) )
7757         goto end;
7758     r = ReadClassStm( stm, &clsid );
7759     if( FAILED( r ) )
7760         goto end;
7761
7762     r = STREAM_ReadString( stm, &szCLSIDName );
7763     if( FAILED( r ) )
7764         goto end;
7765
7766     r = STREAM_ReadString( stm, &szOleTypeName );
7767     if( FAILED( r ) )
7768         goto end;
7769
7770     r = STREAM_ReadString( stm, &szProgIDName );
7771     if( FAILED( r ) )
7772         goto end;
7773
7774     r = IStream_Read( stm, unknown2, sizeof(unknown2), &count );
7775     if( FAILED( r ) || ( count != sizeof(unknown2) ) )
7776         goto end;
7777
7778     /* ok, success... now we just need to store what we found */
7779     if( pcf )
7780         *pcf = RegisterClipboardFormatW( szOleTypeName );
7781     CoTaskMemFree( szOleTypeName );
7782
7783     if( lplpszUserType )
7784         *lplpszUserType = szCLSIDName;
7785     CoTaskMemFree( szProgIDName );
7786
7787 end:
7788     IStream_Release( stm );
7789
7790     return r;
7791 }
7792
7793
7794 /*************************************************************************
7795  * OLECONVERT_CreateCompObjStream [Internal]
7796  *
7797  * Creates a "\001CompObj" is the destination IStorage if necessary.
7798  *
7799  * PARAMS
7800  *     pStorage       [I] The dest IStorage to create the CompObj Stream
7801  *                        if necessary.
7802  *     strOleTypeName [I] The ProgID
7803  *
7804  * RETURNS
7805  *     Success:  S_OK
7806  *     Failure:  REGDB_E_CLASSNOTREG if cannot reconstruct the stream
7807  *
7808  * NOTES
7809  *     This function is used by OleConvertOLESTREAMToIStorage only.
7810  *
7811  *     The stream data is stored in the OLESTREAM and there should be
7812  *     no need to recreate the stream.  If the stream is manually
7813  *     deleted it will attempt to create it by querying the registry.
7814  *
7815  *
7816  */
7817 HRESULT OLECONVERT_CreateCompObjStream(LPSTORAGE pStorage, LPCSTR strOleTypeName)
7818 {
7819     IStream *pStream;
7820     HRESULT hStorageRes, hRes = S_OK;
7821     OLECONVERT_ISTORAGE_COMPOBJ IStorageCompObj;
7822     static const WCHAR wstrStreamName[] = {1,'C', 'o', 'm', 'p', 'O', 'b', 'j', 0};
7823     WCHAR bufferW[OLESTREAM_MAX_STR_LEN];
7824
7825     BYTE pCompObjUnknown1[] = {0x01, 0x00, 0xFE, 0xFF, 0x03, 0x0A, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF};
7826     BYTE pCompObjUnknown2[] = {0xF4, 0x39, 0xB2, 0x71};
7827
7828     /* Initialize the CompObj structure */
7829     memset(&IStorageCompObj, 0, sizeof(IStorageCompObj));
7830     memcpy(IStorageCompObj.byUnknown1, pCompObjUnknown1, sizeof(pCompObjUnknown1));
7831     memcpy(IStorageCompObj.byUnknown2, pCompObjUnknown2, sizeof(pCompObjUnknown2));
7832
7833
7834     /*  Create a CompObj stream if it doesn't exist */
7835     hStorageRes = IStorage_CreateStream(pStorage, wstrStreamName,
7836         STGM_WRITE  | STGM_SHARE_EXCLUSIVE, 0, 0, &pStream );
7837     if(hStorageRes == S_OK)
7838     {
7839         /* copy the OleTypeName to the compobj struct */
7840         IStorageCompObj.dwOleTypeNameLength = strlen(strOleTypeName)+1;
7841         strcpy(IStorageCompObj.strOleTypeName, strOleTypeName);
7842
7843         /* copy the OleTypeName to the compobj struct */
7844         /* Note: in the test made, these were Identical      */
7845         IStorageCompObj.dwProgIDNameLength = strlen(strOleTypeName)+1;
7846         strcpy(IStorageCompObj.strProgIDName, strOleTypeName);
7847
7848         /* Get the CLSID */
7849         MultiByteToWideChar( CP_ACP, 0, IStorageCompObj.strProgIDName, -1,
7850                              bufferW, OLESTREAM_MAX_STR_LEN );
7851         hRes = CLSIDFromProgID(bufferW, &(IStorageCompObj.clsid));
7852
7853         if(hRes == S_OK)
7854         {
7855             HKEY hKey;
7856             LONG hErr;
7857             /* Get the CLSID Default Name from the Registry */
7858             hErr = RegOpenKeyA(HKEY_CLASSES_ROOT, IStorageCompObj.strProgIDName, &hKey);
7859             if(hErr == ERROR_SUCCESS)
7860             {
7861                 char strTemp[OLESTREAM_MAX_STR_LEN];
7862                 IStorageCompObj.dwCLSIDNameLength = OLESTREAM_MAX_STR_LEN;
7863                 hErr = RegQueryValueA(hKey, NULL, strTemp, (LONG*) &(IStorageCompObj.dwCLSIDNameLength));
7864                 if(hErr == ERROR_SUCCESS)
7865                 {
7866                     strcpy(IStorageCompObj.strCLSIDName, strTemp);
7867                 }
7868                 RegCloseKey(hKey);
7869             }
7870         }
7871
7872         /* Write CompObj Structure to stream */
7873         hRes = IStream_Write(pStream, IStorageCompObj.byUnknown1, sizeof(IStorageCompObj.byUnknown1), NULL);
7874
7875         WriteClassStm(pStream,&(IStorageCompObj.clsid));
7876
7877         hRes = IStream_Write(pStream, &(IStorageCompObj.dwCLSIDNameLength), sizeof(IStorageCompObj.dwCLSIDNameLength), NULL);
7878         if(IStorageCompObj.dwCLSIDNameLength > 0)
7879         {
7880             hRes = IStream_Write(pStream, IStorageCompObj.strCLSIDName, IStorageCompObj.dwCLSIDNameLength, NULL);
7881         }
7882         hRes = IStream_Write(pStream, &(IStorageCompObj.dwOleTypeNameLength) , sizeof(IStorageCompObj.dwOleTypeNameLength), NULL);
7883         if(IStorageCompObj.dwOleTypeNameLength > 0)
7884         {
7885             hRes = IStream_Write(pStream, IStorageCompObj.strOleTypeName , IStorageCompObj.dwOleTypeNameLength, NULL);
7886         }
7887         hRes = IStream_Write(pStream, &(IStorageCompObj.dwProgIDNameLength) , sizeof(IStorageCompObj.dwProgIDNameLength), NULL);
7888         if(IStorageCompObj.dwProgIDNameLength > 0)
7889         {
7890             hRes = IStream_Write(pStream, IStorageCompObj.strProgIDName , IStorageCompObj.dwProgIDNameLength, NULL);
7891         }
7892         hRes = IStream_Write(pStream, IStorageCompObj.byUnknown2 , sizeof(IStorageCompObj.byUnknown2), NULL);
7893         IStream_Release(pStream);
7894     }
7895     return hRes;
7896 }
7897
7898
7899 /*************************************************************************
7900  * OLECONVERT_CreateOlePresStream[Internal]
7901  *
7902  * Creates the "\002OlePres000" Stream with the Metafile data
7903  *
7904  * PARAMS
7905  *     pStorage     [I] The dest IStorage to create \002OLEPres000 stream in.
7906  *     dwExtentX    [I] Width of the Metafile
7907  *     dwExtentY    [I] Height of the Metafile
7908  *     pData        [I] Metafile data
7909  *     dwDataLength [I] Size of the Metafile data
7910  *
7911  * RETURNS
7912  *     Success:  S_OK
7913  *     Failure:  CONVERT10_E_OLESTREAM_PUT for invalid Put
7914  *
7915  * NOTES
7916  *     This function is used by OleConvertOLESTREAMToIStorage only.
7917  *
7918  */
7919 static void OLECONVERT_CreateOlePresStream(LPSTORAGE pStorage, DWORD dwExtentX, DWORD dwExtentY , BYTE *pData, DWORD dwDataLength)
7920 {
7921     HRESULT hRes;
7922     IStream *pStream;
7923     static const WCHAR wstrStreamName[] = {2, 'O', 'l', 'e', 'P', 'r', 'e', 's', '0', '0', '0', 0};
7924     BYTE pOlePresStreamHeader [] =
7925     {
7926         0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00,
7927         0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
7928         0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
7929         0x00, 0x00, 0x00, 0x00
7930     };
7931
7932     BYTE pOlePresStreamHeaderEmpty [] =
7933     {
7934         0x00, 0x00, 0x00, 0x00,
7935         0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
7936         0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
7937         0x00, 0x00, 0x00, 0x00
7938     };
7939
7940     /* Create the OlePres000 Stream */
7941     hRes = IStorage_CreateStream(pStorage, wstrStreamName,
7942         STGM_CREATE | STGM_WRITE  | STGM_SHARE_EXCLUSIVE, 0, 0, &pStream );
7943
7944     if(hRes == S_OK)
7945     {
7946         DWORD nHeaderSize;
7947         OLECONVERT_ISTORAGE_OLEPRES OlePres;
7948
7949         memset(&OlePres, 0, sizeof(OlePres));
7950         /* Do we have any metafile data to save */
7951         if(dwDataLength > 0)
7952         {
7953             memcpy(OlePres.byUnknown1, pOlePresStreamHeader, sizeof(pOlePresStreamHeader));
7954             nHeaderSize = sizeof(pOlePresStreamHeader);
7955         }
7956         else
7957         {
7958             memcpy(OlePres.byUnknown1, pOlePresStreamHeaderEmpty, sizeof(pOlePresStreamHeaderEmpty));
7959             nHeaderSize = sizeof(pOlePresStreamHeaderEmpty);
7960         }
7961         /* Set width and height of the metafile */
7962         OlePres.dwExtentX = dwExtentX;
7963         OlePres.dwExtentY = -dwExtentY;
7964
7965         /* Set Data and Length */
7966         if(dwDataLength > sizeof(METAFILEPICT16))
7967         {
7968             OlePres.dwSize = dwDataLength - sizeof(METAFILEPICT16);
7969             OlePres.pData = &(pData[8]);
7970         }
7971         /* Save OlePres000 Data to Stream */
7972         hRes = IStream_Write(pStream, OlePres.byUnknown1, nHeaderSize, NULL);
7973         hRes = IStream_Write(pStream, &(OlePres.dwExtentX), sizeof(OlePres.dwExtentX), NULL);
7974         hRes = IStream_Write(pStream, &(OlePres.dwExtentY), sizeof(OlePres.dwExtentY), NULL);
7975         hRes = IStream_Write(pStream, &(OlePres.dwSize), sizeof(OlePres.dwSize), NULL);
7976         if(OlePres.dwSize > 0)
7977         {
7978             hRes = IStream_Write(pStream, OlePres.pData, OlePres.dwSize, NULL);
7979         }
7980         IStream_Release(pStream);
7981     }
7982 }
7983
7984 /*************************************************************************
7985  * OLECONVERT_CreateOle10NativeStream [Internal]
7986  *
7987  * Creates the "\001Ole10Native" Stream (should contain a BMP)
7988  *
7989  * PARAMS
7990  *     pStorage     [I] Dest storage to create the stream in
7991  *     pData        [I] Ole10 Native Data (ex. bmp)
7992  *     dwDataLength [I] Size of the Ole10 Native Data
7993  *
7994  * RETURNS
7995  *     Nothing
7996  *
7997  * NOTES
7998  *     This function is used by OleConvertOLESTREAMToIStorage only.
7999  *
8000  *     Might need to verify the data and return appropriate error message
8001  *
8002  */
8003 static void OLECONVERT_CreateOle10NativeStream(LPSTORAGE pStorage, const BYTE *pData, DWORD dwDataLength)
8004 {
8005     HRESULT hRes;
8006     IStream *pStream;
8007     static const WCHAR wstrStreamName[] = {1, 'O', 'l', 'e', '1', '0', 'N', 'a', 't', 'i', 'v', 'e', 0};
8008
8009     /* Create the Ole10Native Stream */
8010     hRes = IStorage_CreateStream(pStorage, wstrStreamName,
8011         STGM_CREATE | STGM_WRITE  | STGM_SHARE_EXCLUSIVE, 0, 0, &pStream );
8012
8013     if(hRes == S_OK)
8014     {
8015         /* Write info to stream */
8016         hRes = IStream_Write(pStream, &dwDataLength, sizeof(dwDataLength), NULL);
8017         hRes = IStream_Write(pStream, pData, dwDataLength, NULL);
8018         IStream_Release(pStream);
8019     }
8020
8021 }
8022
8023 /*************************************************************************
8024  * OLECONVERT_GetOLE10ProgID [Internal]
8025  *
8026  * Finds the ProgID (or OleTypeID) from the IStorage
8027  *
8028  * PARAMS
8029  *     pStorage        [I] The Src IStorage to get the ProgID
8030  *     strProgID       [I] the ProgID string to get
8031  *     dwSize          [I] the size of the string
8032  *
8033  * RETURNS
8034  *     Success:  S_OK
8035  *     Failure:  REGDB_E_CLASSNOTREG if cannot reconstruct the stream
8036  *
8037  * NOTES
8038  *     This function is used by OleConvertIStorageToOLESTREAM only.
8039  *
8040  *
8041  */
8042 static HRESULT OLECONVERT_GetOLE10ProgID(LPSTORAGE pStorage, char *strProgID, DWORD *dwSize)
8043 {
8044     HRESULT hRes;
8045     IStream *pStream;
8046     LARGE_INTEGER iSeekPos;
8047     OLECONVERT_ISTORAGE_COMPOBJ CompObj;
8048     static const WCHAR wstrStreamName[] = {1,'C', 'o', 'm', 'p', 'O', 'b', 'j', 0};
8049
8050     /* Open the CompObj Stream */
8051     hRes = IStorage_OpenStream(pStorage, wstrStreamName, NULL,
8052         STGM_READ  | STGM_SHARE_EXCLUSIVE, 0, &pStream );
8053     if(hRes == S_OK)
8054     {
8055
8056         /*Get the OleType from the CompObj Stream */
8057         iSeekPos.u.LowPart = sizeof(CompObj.byUnknown1) + sizeof(CompObj.clsid);
8058         iSeekPos.u.HighPart = 0;
8059
8060         IStream_Seek(pStream, iSeekPos, STREAM_SEEK_SET, NULL);
8061         IStream_Read(pStream, &CompObj.dwCLSIDNameLength, sizeof(CompObj.dwCLSIDNameLength), NULL);
8062         iSeekPos.u.LowPart = CompObj.dwCLSIDNameLength;
8063         IStream_Seek(pStream, iSeekPos, STREAM_SEEK_CUR , NULL);
8064         IStream_Read(pStream, &CompObj.dwOleTypeNameLength, sizeof(CompObj.dwOleTypeNameLength), NULL);
8065         iSeekPos.u.LowPart = CompObj.dwOleTypeNameLength;
8066         IStream_Seek(pStream, iSeekPos, STREAM_SEEK_CUR , NULL);
8067
8068         IStream_Read(pStream, dwSize, sizeof(*dwSize), NULL);
8069         if(*dwSize > 0)
8070         {
8071             IStream_Read(pStream, strProgID, *dwSize, NULL);
8072         }
8073         IStream_Release(pStream);
8074     }
8075     else
8076     {
8077         STATSTG stat;
8078         LPOLESTR wstrProgID;
8079
8080         /* Get the OleType from the registry */
8081         REFCLSID clsid = &(stat.clsid);
8082         IStorage_Stat(pStorage, &stat, STATFLAG_NONAME);
8083         hRes = ProgIDFromCLSID(clsid, &wstrProgID);
8084         if(hRes == S_OK)
8085         {
8086             *dwSize = WideCharToMultiByte(CP_ACP, 0, wstrProgID, -1, strProgID, *dwSize, NULL, FALSE);
8087         }
8088
8089     }
8090     return hRes;
8091 }
8092
8093 /*************************************************************************
8094  * OLECONVERT_GetOle10PresData [Internal]
8095  *
8096  * Converts IStorage "/001Ole10Native" stream to a OLE10 Stream
8097  *
8098  * PARAMS
8099  *     pStorage     [I] Src IStroage
8100  *     pOleStream   [I] Dest OleStream Mem Struct
8101  *
8102  * RETURNS
8103  *     Nothing
8104  *
8105  * NOTES
8106  *     This function is used by OleConvertIStorageToOLESTREAM only.
8107  *
8108  *     Memory allocated for pData must be freed by the caller
8109  *
8110  *
8111  */
8112 static void OLECONVERT_GetOle10PresData(LPSTORAGE pStorage, OLECONVERT_OLESTREAM_DATA *pOleStreamData)
8113 {
8114
8115     HRESULT hRes;
8116     IStream *pStream;
8117     static const WCHAR wstrStreamName[] = {1, 'O', 'l', 'e', '1', '0', 'N', 'a', 't', 'i', 'v', 'e', 0};
8118
8119     /* Initialize Default data for OLESTREAM */
8120     pOleStreamData[0].dwOleID = OLESTREAM_ID;
8121     pOleStreamData[0].dwTypeID = 2;
8122     pOleStreamData[1].dwOleID = OLESTREAM_ID;
8123     pOleStreamData[1].dwTypeID = 0;
8124     pOleStreamData[0].dwMetaFileWidth = 0;
8125     pOleStreamData[0].dwMetaFileHeight = 0;
8126     pOleStreamData[0].pData = NULL;
8127     pOleStreamData[1].pData = NULL;
8128
8129     /* Open Ole10Native Stream */
8130     hRes = IStorage_OpenStream(pStorage, wstrStreamName, NULL,
8131         STGM_READ  | STGM_SHARE_EXCLUSIVE, 0, &pStream );
8132     if(hRes == S_OK)
8133     {
8134
8135         /* Read Size and Data */
8136         IStream_Read(pStream, &(pOleStreamData->dwDataLength), sizeof(pOleStreamData->dwDataLength), NULL);
8137         if(pOleStreamData->dwDataLength > 0)
8138         {
8139             pOleStreamData->pData = HeapAlloc(GetProcessHeap(),0,pOleStreamData->dwDataLength);
8140             IStream_Read(pStream, pOleStreamData->pData, pOleStreamData->dwDataLength, NULL);
8141         }
8142         IStream_Release(pStream);
8143     }
8144
8145 }
8146
8147
8148 /*************************************************************************
8149  * OLECONVERT_GetOle20PresData[Internal]
8150  *
8151  * Converts IStorage "/002OlePres000" stream to a OLE10 Stream
8152  *
8153  * PARAMS
8154  *     pStorage         [I] Src IStroage
8155  *     pOleStreamData   [I] Dest OleStream Mem Struct
8156  *
8157  * RETURNS
8158  *     Nothing
8159  *
8160  * NOTES
8161  *     This function is used by OleConvertIStorageToOLESTREAM only.
8162  *
8163  *     Memory allocated for pData must be freed by the caller
8164  */
8165 static void OLECONVERT_GetOle20PresData(LPSTORAGE pStorage, OLECONVERT_OLESTREAM_DATA *pOleStreamData)
8166 {
8167     HRESULT hRes;
8168     IStream *pStream;
8169     OLECONVERT_ISTORAGE_OLEPRES olePress;
8170     static const WCHAR wstrStreamName[] = {2, 'O', 'l', 'e', 'P', 'r', 'e', 's', '0', '0', '0', 0};
8171
8172     /* Initialize Default data for OLESTREAM */
8173     pOleStreamData[0].dwOleID = OLESTREAM_ID;
8174     pOleStreamData[0].dwTypeID = 2;
8175     pOleStreamData[0].dwMetaFileWidth = 0;
8176     pOleStreamData[0].dwMetaFileHeight = 0;
8177     pOleStreamData[0].dwDataLength = OLECONVERT_WriteOLE20ToBuffer(pStorage, &(pOleStreamData[0].pData));
8178     pOleStreamData[1].dwOleID = OLESTREAM_ID;
8179     pOleStreamData[1].dwTypeID = 0;
8180     pOleStreamData[1].dwOleTypeNameLength = 0;
8181     pOleStreamData[1].strOleTypeName[0] = 0;
8182     pOleStreamData[1].dwMetaFileWidth = 0;
8183     pOleStreamData[1].dwMetaFileHeight = 0;
8184     pOleStreamData[1].pData = NULL;
8185     pOleStreamData[1].dwDataLength = 0;
8186
8187
8188     /* Open OlePress000 stream */
8189     hRes = IStorage_OpenStream(pStorage, wstrStreamName, NULL,
8190         STGM_READ  | STGM_SHARE_EXCLUSIVE, 0, &pStream );
8191     if(hRes == S_OK)
8192     {
8193         LARGE_INTEGER iSeekPos;
8194         METAFILEPICT16 MetaFilePict;
8195         static const char strMetafilePictName[] = "METAFILEPICT";
8196
8197         /* Set the TypeID for a Metafile */
8198         pOleStreamData[1].dwTypeID = 5;
8199
8200         /* Set the OleTypeName to Metafile */
8201         pOleStreamData[1].dwOleTypeNameLength = strlen(strMetafilePictName) +1;
8202         strcpy(pOleStreamData[1].strOleTypeName, strMetafilePictName);
8203
8204         iSeekPos.u.HighPart = 0;
8205         iSeekPos.u.LowPart = sizeof(olePress.byUnknown1);
8206
8207         /* Get Presentation Data */
8208         IStream_Seek(pStream, iSeekPos, STREAM_SEEK_SET, NULL);
8209         IStream_Read(pStream, &(olePress.dwExtentX), sizeof(olePress.dwExtentX), NULL);
8210         IStream_Read(pStream, &(olePress.dwExtentY), sizeof(olePress.dwExtentY), NULL);
8211         IStream_Read(pStream, &(olePress.dwSize), sizeof(olePress.dwSize), NULL);
8212
8213         /*Set width and Height */
8214         pOleStreamData[1].dwMetaFileWidth = olePress.dwExtentX;
8215         pOleStreamData[1].dwMetaFileHeight = -olePress.dwExtentY;
8216         if(olePress.dwSize > 0)
8217         {
8218             /* Set Length */
8219             pOleStreamData[1].dwDataLength  = olePress.dwSize + sizeof(METAFILEPICT16);
8220
8221             /* Set MetaFilePict struct */
8222             MetaFilePict.mm = 8;
8223             MetaFilePict.xExt = olePress.dwExtentX;
8224             MetaFilePict.yExt = olePress.dwExtentY;
8225             MetaFilePict.hMF = 0;
8226
8227             /* Get Metafile Data */
8228             pOleStreamData[1].pData = HeapAlloc(GetProcessHeap(),0,pOleStreamData[1].dwDataLength);
8229             memcpy(pOleStreamData[1].pData, &MetaFilePict, sizeof(MetaFilePict));
8230             IStream_Read(pStream, &(pOleStreamData[1].pData[sizeof(MetaFilePict)]), pOleStreamData[1].dwDataLength-sizeof(METAFILEPICT16), NULL);
8231         }
8232         IStream_Release(pStream);
8233     }
8234 }
8235
8236 /*************************************************************************
8237  * OleConvertOLESTREAMToIStorage [OLE32.@]
8238  *
8239  * Read info on MSDN
8240  *
8241  * TODO
8242  *      DVTARGETDEVICE parameter is not handled
8243  *      Still unsure of some mem fields for OLE 10 Stream
8244  *      Still some unknowns for the IStorage: "\002OlePres000", "\001CompObj",
8245  *      and "\001OLE" streams
8246  *
8247  */
8248 HRESULT WINAPI OleConvertOLESTREAMToIStorage (
8249     LPOLESTREAM pOleStream,
8250     LPSTORAGE pstg,
8251     const DVTARGETDEVICE* ptd)
8252 {
8253     int i;
8254     HRESULT hRes=S_OK;
8255     OLECONVERT_OLESTREAM_DATA pOleStreamData[2];
8256
8257     TRACE("%p %p %p\n", pOleStream, pstg, ptd);
8258
8259     memset(pOleStreamData, 0, sizeof(pOleStreamData));
8260
8261     if(ptd != NULL)
8262     {
8263         FIXME("DVTARGETDEVICE is not NULL, unhandled parameter\n");
8264     }
8265
8266     if(pstg == NULL || pOleStream == NULL)
8267     {
8268         hRes = E_INVALIDARG;
8269     }
8270
8271     if(hRes == S_OK)
8272     {
8273         /* Load the OLESTREAM to Memory */
8274         hRes = OLECONVERT_LoadOLE10(pOleStream, &pOleStreamData[0], TRUE);
8275     }
8276
8277     if(hRes == S_OK)
8278     {
8279         /* Load the OLESTREAM to Memory (part 2)*/
8280         hRes = OLECONVERT_LoadOLE10(pOleStream, &pOleStreamData[1], FALSE);
8281     }
8282
8283     if(hRes == S_OK)
8284     {
8285
8286         if(pOleStreamData[0].dwDataLength > sizeof(STORAGE_magic))
8287         {
8288             /* Do we have the IStorage Data in the OLESTREAM */
8289             if(memcmp(pOleStreamData[0].pData, STORAGE_magic, sizeof(STORAGE_magic)) ==0)
8290             {
8291                 OLECONVERT_GetOLE20FromOLE10(pstg, pOleStreamData[0].pData, pOleStreamData[0].dwDataLength);
8292                 OLECONVERT_CreateOlePresStream(pstg, pOleStreamData[1].dwMetaFileWidth, pOleStreamData[1].dwMetaFileHeight, pOleStreamData[1].pData, pOleStreamData[1].dwDataLength);
8293             }
8294             else
8295             {
8296                 /* It must be an original OLE 1.0 source */
8297                 OLECONVERT_CreateOle10NativeStream(pstg, pOleStreamData[0].pData, pOleStreamData[0].dwDataLength);
8298             }
8299         }
8300         else
8301         {
8302             /* It must be an original OLE 1.0 source */
8303             OLECONVERT_CreateOle10NativeStream(pstg, pOleStreamData[0].pData, pOleStreamData[0].dwDataLength);
8304         }
8305
8306         /* Create CompObj Stream if necessary */
8307         hRes = OLECONVERT_CreateCompObjStream(pstg, pOleStreamData[0].strOleTypeName);
8308         if(hRes == S_OK)
8309         {
8310             /*Create the Ole Stream if necessary */
8311             OLECONVERT_CreateOleStream(pstg);
8312         }
8313     }
8314
8315
8316     /* Free allocated memory */
8317     for(i=0; i < 2; i++)
8318     {
8319         HeapFree(GetProcessHeap(),0,pOleStreamData[i].pData);
8320         HeapFree(GetProcessHeap(),0,pOleStreamData[i].pstrOleObjFileName);
8321         pOleStreamData[i].pstrOleObjFileName = NULL;
8322     }
8323     return hRes;
8324 }
8325
8326 /*************************************************************************
8327  * OleConvertIStorageToOLESTREAM [OLE32.@]
8328  *
8329  * Read info on MSDN
8330  *
8331  * Read info on MSDN
8332  *
8333  * TODO
8334  *      Still unsure of some mem fields for OLE 10 Stream
8335  *      Still some unknowns for the IStorage: "\002OlePres000", "\001CompObj",
8336  *      and "\001OLE" streams.
8337  *
8338  */
8339 HRESULT WINAPI OleConvertIStorageToOLESTREAM (
8340     LPSTORAGE pstg,
8341     LPOLESTREAM pOleStream)
8342 {
8343     int i;
8344     HRESULT hRes = S_OK;
8345     IStream *pStream;
8346     OLECONVERT_OLESTREAM_DATA pOleStreamData[2];
8347     static const WCHAR wstrStreamName[] = {1, 'O', 'l', 'e', '1', '0', 'N', 'a', 't', 'i', 'v', 'e', 0};
8348
8349     TRACE("%p %p\n", pstg, pOleStream);
8350
8351     memset(pOleStreamData, 0, sizeof(pOleStreamData));
8352
8353     if(pstg == NULL || pOleStream == NULL)
8354     {
8355         hRes = E_INVALIDARG;
8356     }
8357     if(hRes == S_OK)
8358     {
8359         /* Get the ProgID */
8360         pOleStreamData[0].dwOleTypeNameLength = OLESTREAM_MAX_STR_LEN;
8361         hRes = OLECONVERT_GetOLE10ProgID(pstg, pOleStreamData[0].strOleTypeName, &(pOleStreamData[0].dwOleTypeNameLength));
8362     }
8363     if(hRes == S_OK)
8364     {
8365         /* Was it originally Ole10 */
8366         hRes = IStorage_OpenStream(pstg, wstrStreamName, 0, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &pStream);
8367         if(hRes == S_OK)
8368         {
8369             IStream_Release(pStream);
8370             /* Get Presentation Data for Ole10Native */
8371             OLECONVERT_GetOle10PresData(pstg, pOleStreamData);
8372         }
8373         else
8374         {
8375             /* Get Presentation Data (OLE20) */
8376             OLECONVERT_GetOle20PresData(pstg, pOleStreamData);
8377         }
8378
8379         /* Save OLESTREAM */
8380         hRes = OLECONVERT_SaveOLE10(&(pOleStreamData[0]), pOleStream);
8381         if(hRes == S_OK)
8382         {
8383             hRes = OLECONVERT_SaveOLE10(&(pOleStreamData[1]), pOleStream);
8384         }
8385
8386     }
8387
8388     /* Free allocated memory */
8389     for(i=0; i < 2; i++)
8390     {
8391         HeapFree(GetProcessHeap(),0,pOleStreamData[i].pData);
8392     }
8393
8394     return hRes;
8395 }
8396
8397 /***********************************************************************
8398  *              GetConvertStg (OLE32.@)
8399  */
8400 HRESULT WINAPI GetConvertStg(IStorage *stg) {
8401     FIXME("unimplemented stub!\n");
8402     return E_FAIL;
8403 }
8404
8405 /******************************************************************************
8406  * StgIsStorageFile [OLE32.@]
8407  * Verify if the file contains a storage object
8408  *
8409  * PARAMS
8410  *  fn      [ I] Filename
8411  *
8412  * RETURNS
8413  *  S_OK    if file has magic bytes as a storage object
8414  *  S_FALSE if file is not storage
8415  */
8416 HRESULT WINAPI
8417 StgIsStorageFile(LPCOLESTR fn)
8418 {
8419         HANDLE          hf;
8420         BYTE            magic[8];
8421         DWORD           bytes_read;
8422
8423         TRACE("%s\n", debugstr_w(fn));
8424         hf = CreateFileW(fn, GENERIC_READ,
8425                          FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
8426                          NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
8427
8428         if (hf == INVALID_HANDLE_VALUE)
8429                 return STG_E_FILENOTFOUND;
8430
8431         if (!ReadFile(hf, magic, 8, &bytes_read, NULL))
8432         {
8433                 WARN(" unable to read file\n");
8434                 CloseHandle(hf);
8435                 return S_FALSE;
8436         }
8437
8438         CloseHandle(hf);
8439
8440         if (bytes_read != 8) {
8441                 TRACE(" too short\n");
8442                 return S_FALSE;
8443         }
8444
8445         if (!memcmp(magic,STORAGE_magic,8)) {
8446                 TRACE(" -> YES\n");
8447                 return S_OK;
8448         }
8449
8450         TRACE(" -> Invalid header.\n");
8451         return S_FALSE;
8452 }
8453
8454 /***********************************************************************
8455  *              WriteClassStm (OLE32.@)
8456  *
8457  * Writes a CLSID to a stream.
8458  *
8459  * PARAMS
8460  *  pStm   [I] Stream to write to.
8461  *  rclsid [I] CLSID to write.
8462  *
8463  * RETURNS
8464  *  Success: S_OK.
8465  *  Failure: HRESULT code.
8466  */
8467 HRESULT WINAPI WriteClassStm(IStream *pStm,REFCLSID rclsid)
8468 {
8469     TRACE("(%p,%p)\n",pStm,rclsid);
8470
8471     if (!pStm || !rclsid)
8472         return E_INVALIDARG;
8473
8474     return IStream_Write(pStm,rclsid,sizeof(CLSID),NULL);
8475 }
8476
8477 /***********************************************************************
8478  *              ReadClassStm (OLE32.@)
8479  *
8480  * Reads a CLSID from a stream.
8481  *
8482  * PARAMS
8483  *  pStm   [I] Stream to read from.
8484  *  rclsid [O] CLSID to read.
8485  *
8486  * RETURNS
8487  *  Success: S_OK.
8488  *  Failure: HRESULT code.
8489  */
8490 HRESULT WINAPI ReadClassStm(IStream *pStm,CLSID *pclsid)
8491 {
8492     ULONG nbByte;
8493     HRESULT res;
8494
8495     TRACE("(%p,%p)\n",pStm,pclsid);
8496
8497     if (!pStm || !pclsid)
8498         return E_INVALIDARG;
8499
8500     /* clear the output args */
8501     *pclsid = CLSID_NULL;
8502
8503     res = IStream_Read(pStm,(void*)pclsid,sizeof(CLSID),&nbByte);
8504
8505     if (FAILED(res))
8506         return res;
8507
8508     if (nbByte != sizeof(CLSID))
8509         return STG_E_READFAULT;
8510     else
8511         return S_OK;
8512 }