ole/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  */
  12
  13 #include <assert.h>
  14 #include <stdlib.h>
  15 #include <stdio.h>
  16 #include <string.h>
  17
  18 #include "windows.h"
  19 #include "winerror.h"
  20 #include "file.h"
  21 #include "ole.h"
  22 #include "ole2.h"
  23 #include "objbase.h"
  24 #include "crtdll.h"
  25 #include "tchar.h"
  26 #include "heap.h"
  27
  28 #include "winnt.h"
  29 #include "winbase.h"
  30 #include "debug.h"
  31
  32 #include "storage32.h"
  33
  34 #define FILE_BEGIN 0
  35
  36 static const char rootPropertyName[] = "Root Entry";
  37
  38 /***********************************************************************
  39  * Forward declaration of internal functions used by the method DestroyElement
  40  */
  41 static HRESULT deleteStorageProperty(
  42   Storage32Impl *parentStorage,
  43   OLECHAR32     *propertyToDeleteName);
  44
  45 static HRESULT deleteStreamProperty(
  46   Storage32Impl *parentStorage,
  47   ULONG         foundPropertyIndexToDelete,
  48   StgProperty   propertyToDelete);
  49
  50 static HRESULT findPlaceholder(
  51   Storage32Impl *storage,
  52   ULONG         propertyIndexToStore,
  53   ULONG         storagePropertyIndex,
  54   INT32         typeOfRelation);
  55
  56 static HRESULT adjustPropertyChain(
  57   Storage32Impl *This,
  58   StgProperty   propertyToDelete,
  59   StgProperty   parentProperty,
  60   ULONG         parentPropertyId,
  61   INT32         typeOfRelation);
  62
  63 /***********************************************************************
  64  * Declaration of the functions used to manipulate StgProperty
  65  */
  66
  67 static ULONG getFreeProperty(
  68   Storage32Impl *storage);
  69
  70 static void updatePropertyChain(
  71   Storage32Impl *storage,
  72   ULONG       newPropertyIndex,
  73   StgProperty newProperty);
  74
  75 static LONG propertyNameCmp(
  76   OLECHAR32 *newProperty,
  77   OLECHAR32 *currentProperty);
  78
  79
  80 /***********************************************************************
  81  * Declaration of miscellaneous functions...
  82  */
  83 static HRESULT validateSTGM(DWORD stgmValue);
  84
  85 static DWORD GetShareModeFromSTGM(DWORD stgm);
  86 static DWORD GetAccessModeFromSTGM(DWORD stgm);
  87 static DWORD GetCreationModeFromSTGM(DWORD stgm);
  88
  89 /*
  90  * Virtual function table for the IStorage32Impl class.
  91  */
  92 static ICOM_VTABLE(IStorage32) Storage32Impl_Vtbl =
  93 {
  94     Storage32BaseImpl_QueryInterface,
  95     Storage32BaseImpl_AddRef,
  96     Storage32BaseImpl_Release,
  97     Storage32BaseImpl_CreateStream,
  98     Storage32BaseImpl_OpenStream,
  99     Storage32Impl_CreateStorage,
 100     Storage32BaseImpl_OpenStorage,
 101     Storage32Impl_CopyTo,
 102     Storage32Impl_MoveElementTo,
 103     Storage32Impl_Commit,
 104     Storage32Impl_Revert,
 105     Storage32BaseImpl_EnumElements,
 106     Storage32Impl_DestroyElement,
 107     Storage32BaseImpl_RenameElement,
 108     Storage32Impl_SetElementTimes,
 109     Storage32BaseImpl_SetClass,
 110     Storage32Impl_SetStateBits,
 111     Storage32BaseImpl_Stat
 112 };
 113
 114 /*
 115  * Virtual function table for the Storage32InternalImpl class.
 116  */
 117 static ICOM_VTABLE(IStorage32) Storage32InternalImpl_Vtbl =
 118   {
 119     Storage32BaseImpl_QueryInterface,
 120     Storage32BaseImpl_AddRef,
 121     Storage32BaseImpl_Release,
 122     Storage32BaseImpl_CreateStream,
 123     Storage32BaseImpl_OpenStream,
 124     Storage32Impl_CreateStorage,
 125     Storage32BaseImpl_OpenStorage,
 126     Storage32Impl_CopyTo,
 127     Storage32Impl_MoveElementTo,
 128     Storage32InternalImpl_Commit,
 129     Storage32InternalImpl_Revert,
 130     Storage32BaseImpl_EnumElements,
 131     Storage32Impl_DestroyElement,
 132     Storage32BaseImpl_RenameElement,
 133     Storage32Impl_SetElementTimes,
 134     Storage32BaseImpl_SetClass,
 135     Storage32Impl_SetStateBits,
 136     Storage32BaseImpl_Stat
 137 };
 138
 139 /*
 140  * Virtual function table for the IEnumSTATSTGImpl class.
 141  */
 142 static ICOM_VTABLE(IEnumSTATSTG) IEnumSTATSTGImpl_Vtbl =
 143 {
 144     IEnumSTATSTGImpl_QueryInterface,
 145     IEnumSTATSTGImpl_AddRef,
 146     IEnumSTATSTGImpl_Release,
 147     IEnumSTATSTGImpl_Next,
 148     IEnumSTATSTGImpl_Skip,
 149     IEnumSTATSTGImpl_Reset,
 150     IEnumSTATSTGImpl_Clone
 151 };
 152
 153
 154
 155
 156
 157 /************************************************************************
 158 ** Storage32BaseImpl implementatiion
 159 */
 160
 161 /************************************************************************
 162  * Storage32BaseImpl_QueryInterface (IUnknown)
 163  *
 164  * This method implements the common QueryInterface for all IStorage32
 165  * implementations contained in this file.
 166  *
 167  * See Windows documentation for more details on IUnknown methods.
 168  */
 169 HRESULT WINAPI Storage32BaseImpl_QueryInterface(
 170   IStorage32*        iface,
 171   REFIID             riid,
 172   void**             ppvObject)
 173 {
 174   ICOM_THIS(Storage32BaseImpl,iface);
 175   /*
 176    * Perform a sanity check on the parameters.
 177    */
 178   if ( (This==0) || (ppvObject==0) )
 179     return E_INVALIDARG;
 180
 181   /*
 182    * Initialize the return parameter.
 183    */
 184   *ppvObject = 0;
 185
 186   /*
 187    * Compare the riid with the interface IDs implemented by this object.
 188    */
 189   if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0)
 190   {
 191     *ppvObject = (IStorage32*)This;
 192   }
 193   else if (memcmp(&IID_IStorage, riid, sizeof(IID_IStorage)) == 0)
 194   {
 195     *ppvObject = (IStorage32*)This;
 196   }
 197
 198   /*
 199    * Check that we obtained an interface.
 200    */
 201   if ((*ppvObject)==0)
 202     return E_NOINTERFACE;
 203
 204   /*
 205    * Query Interface always increases the reference count by one when it is
 206    * successful
 207    */
 208   Storage32BaseImpl_AddRef(iface);
 209
 210   return S_OK;
 211 }
 212
 213 /************************************************************************
 214  * Storage32BaseImpl_AddRef (IUnknown)
 215  *
 216  * This method implements the common AddRef for all IStorage32
 217  * implementations contained in this file.
 218  *
 219  * See Windows documentation for more details on IUnknown methods.
 220  */
 221 ULONG WINAPI Storage32BaseImpl_AddRef(
 222             IStorage32* iface)
 223 {
 224   ICOM_THIS(Storage32BaseImpl,iface);
 225   This->ref++;
 226
 227   return This->ref;
 228 }
 229
 230 /************************************************************************
 231  * Storage32BaseImpl_Release (IUnknown)
 232  *
 233  * This method implements the common Release for all IStorage32
 234  * implementations contained in this file.
 235  *
 236  * See Windows documentation for more details on IUnknown methods.
 237  */
 238 ULONG WINAPI Storage32BaseImpl_Release(
 239       IStorage32* iface)
 240 {
 241   ICOM_THIS(Storage32BaseImpl,iface);
 242   /*
 243    * Decrease the reference count on this object.
 244    */
 245   This->ref--;
 246
 247   /*
 248    * If the reference count goes down to 0, perform suicide.
 249    */
 250   if (This->ref==0)
 251   {
 252     /*
 253      * Since we are using a system of base-classes, we want to call the
 254      * destructor of the appropriate derived class. To do this, we are
 255      * using virtual functions to implement the destructor.
 256      */
 257     This->v_destructor(This);
 258
 259     return 0;
 260   }
 261
 262   return This->ref;
 263 }
 264
 265 /************************************************************************
 266  * Storage32BaseImpl_OpenStream (IStorage)
 267  *
 268  * This method will open the specified stream object from the current storage.
 269  *
 270  * See Windows documentation for more details on IStorage methods.
 271  */
 272 HRESULT WINAPI Storage32BaseImpl_OpenStream(
 273   IStorage32*        iface,
 274   const OLECHAR32*   pwcsName,  /* [string][in] */
 275   void*              reserved1, /* [unique][in] */
 276   DWORD              grfMode,   /* [in]  */
 277   DWORD              reserved2, /* [in]  */
 278   IStream32**        ppstm)     /* [out] */
 279 {
 280   ICOM_THIS(Storage32BaseImpl,iface);
 281   IEnumSTATSTGImpl* propertyEnumeration;
 282   StgStreamImpl*    newStream;
 283   StgProperty       currentProperty;
 284   ULONG             foundPropertyIndex;
 285
 286   /*
 287    * Perform a sanity check on the parameters.
 288    */
 289   if ( (pwcsName==NULL) || (ppstm==0) )
 290     return E_INVALIDARG;
 291
 292   /*
 293    * Initialize the out parameter
 294    */
 295   *ppstm = 0;
 296
 297   /*
 298    * Validate the STGM flags
 299    */
 300   if ( FAILED( validateSTGM(grfMode) ))
 301     return STG_E_INVALIDFLAG;
 302
 303   /*
 304    * As documented.
 305    */
 306   if ( !(grfMode & STGM_SHARE_EXCLUSIVE) ||
 307         (grfMode & STGM_DELETEONRELEASE) ||
 308         (grfMode & STGM_TRANSACTED) )
 309     return STG_E_INVALIDFUNCTION;
 310
 311   /*
 312    * Create a property enumeration to search the properties
 313    */
 314   propertyEnumeration = IEnumSTATSTGImpl_Construct(
 315     This->ancestorStorage,
 316     This->rootPropertySetIndex);
 317
 318   /*
 319    * Search the enumeration for the property with the given name
 320    */
 321   foundPropertyIndex = IEnumSTATSTGImpl_FindProperty(
 322     propertyEnumeration,
 323     pwcsName,
 324     &currentProperty);
 325
 326   /*
 327    * Delete the property enumeration since we don't need it anymore
 328    */
 329   IEnumSTATSTGImpl_Destroy(propertyEnumeration);
 330
 331   /*
 332    * If it was found, construct the stream object and return a pointer to it.
 333    */
 334   if ( (foundPropertyIndex!=PROPERTY_NULL) &&
 335        (currentProperty.propertyType==PROPTYPE_STREAM) )
 336   {
 337     newStream = StgStreamImpl_Construct(This, foundPropertyIndex);
 338
 339     if (newStream!=0)
 340     {
 341       *ppstm = (IStream32*)newStream;
 342
 343       /*
 344        * Since we are returning a pointer to the interface, we have to
 345        * nail down the reference.
 346        */
 347       StgStreamImpl_AddRef(*ppstm);
 348
 349       return S_OK;
 350     }
 351
 352     return E_OUTOFMEMORY;
 353   }
 354
 355   return STG_E_FILENOTFOUND;
 356 }
 357
 358 /************************************************************************
 359  * Storage32BaseImpl_OpenStorage (IStorage)
 360  *
 361  * This method will open a new storage object from the current storage.
 362  *
 363  * See Windows documentation for more details on IStorage methods.
 364  */
 365 HRESULT WINAPI Storage32BaseImpl_OpenStorage(
 366   IStorage32*        iface,
 367   const OLECHAR32*   pwcsName,      /* [string][unique][in] */
 368   IStorage32*        pstgPriority,  /* [unique][in] */
 369   DWORD              grfMode,       /* [in] */
 370   SNB32              snbExclude,    /* [unique][in] */
 371   DWORD              reserved,      /* [in] */
 372   IStorage32**       ppstg)         /* [out] */
 373 {
 374   ICOM_THIS(Storage32BaseImpl,iface);
 375   Storage32InternalImpl* newStorage;
 376   IEnumSTATSTGImpl*      propertyEnumeration;
 377   StgProperty            currentProperty;
 378   ULONG                  foundPropertyIndex;
 379
 380   /*
 381    * Perform a sanity check on the parameters.
 382    */
 383   if ( (This==0) || (pwcsName==NULL) || (ppstg==0) )
 384     return E_INVALIDARG;
 385
 386   /*
 387    * Validate the STGM flags
 388    */
 389   if ( FAILED( validateSTGM(grfMode) ))
 390     return STG_E_INVALIDFLAG;
 391
 392   /*
 393    * As documented.
 394    */
 395   if ( !(grfMode & STGM_SHARE_EXCLUSIVE) ||
 396         (grfMode & STGM_DELETEONRELEASE) ||
 397         (grfMode & STGM_PRIORITY) )
 398     return STG_E_INVALIDFUNCTION;
 399
 400   /*
 401    * Initialize the out parameter
 402    */
 403   *ppstg = 0;
 404
 405   /*
 406    * Create a property enumeration to search the properties
 407    */
 408   propertyEnumeration = IEnumSTATSTGImpl_Construct(
 409                           This->ancestorStorage,
 410                           This->rootPropertySetIndex);
 411
 412   /*
 413    * Search the enumeration for the property with the given name
 414    */
 415   foundPropertyIndex = IEnumSTATSTGImpl_FindProperty(
 416                          propertyEnumeration,
 417                          pwcsName,
 418                          &currentProperty);
 419
 420   /*
 421    * Delete the property enumeration since we don't need it anymore
 422    */
 423   IEnumSTATSTGImpl_Destroy(propertyEnumeration);
 424
 425   /*
 426    * If it was found, construct the stream object and return a pointer to it.
 427    */
 428   if ( (foundPropertyIndex!=PROPERTY_NULL) &&
 429        (currentProperty.propertyType==PROPTYPE_STORAGE) )
 430   {
 431     /*
 432      * Construct a new Storage object
 433      */
 434     newStorage = Storage32InternalImpl_Construct(
 435                    This->ancestorStorage,
 436                    foundPropertyIndex);
 437
 438     if (newStorage != 0)
 439     {
 440       *ppstg = (IStorage32*)newStorage;
 441
 442       /*
 443        * Since we are returning a pointer to the interface,
 444        * we have to nail down the reference.
 445        */
 446       Storage32BaseImpl_AddRef(*ppstg);
 447
 448       return S_OK;
 449     }
 450
 451     return STG_E_INSUFFICIENTMEMORY;
 452   }
 453
 454   return STG_E_FILENOTFOUND;
 455 }
 456
 457 /************************************************************************
 458  * Storage32BaseImpl_EnumElements (IStorage)
 459  *
 460  * This method will create an enumerator object that can be used to
 461  * retrieve informatino about all the properties in the storage object.
 462  *
 463  * See Windows documentation for more details on IStorage methods.
 464  */
 465 HRESULT WINAPI Storage32BaseImpl_EnumElements(
 466   IStorage32*        iface,
 467   DWORD              reserved1, /* [in] */
 468   void*              reserved2, /* [size_is][unique][in] */
 469   DWORD              reserved3, /* [in] */
 470   IEnumSTATSTG**     ppenum)    /* [out] */
 471 {
 472   ICOM_THIS(Storage32BaseImpl,iface);
 473   IEnumSTATSTGImpl* newEnum;
 474
 475   /*
 476    * Perform a sanity check on the parameters.
 477    */
 478   if ( (This==0) || (ppenum==0))
 479     return E_INVALIDARG;
 480
 481   /*
 482    * Construct the enumerator.
 483    */
 484   newEnum = IEnumSTATSTGImpl_Construct(
 485               This->ancestorStorage,
 486               This->rootPropertySetIndex);
 487
 488   if (newEnum!=0)
 489   {
 490     *ppenum = (IEnumSTATSTG*)newEnum;
 491
 492     /*
 493      * Don't forget to nail down a reference to the new object before
 494      * returning it.
 495      */
 496     IEnumSTATSTGImpl_AddRef(*ppenum);
 497
 498     return S_OK;
 499   }
 500
 501   return E_OUTOFMEMORY;
 502 }
 503
 504 /************************************************************************
 505  * Storage32BaseImpl_Stat (IStorage)
 506  *
 507  * This method will retrieve information about this storage object.
 508  *
 509  * See Windows documentation for more details on IStorage methods.
 510  */
 511 HRESULT WINAPI Storage32BaseImpl_Stat(
 512   IStorage32*        iface,
 513   STATSTG*           pstatstg,     /* [out] */
 514   DWORD              grfStatFlag)  /* [in] */
 515 {
 516   ICOM_THIS(Storage32BaseImpl,iface);
 517   StgProperty    curProperty;
 518   BOOL32         readSucessful;
 519
 520   /*
 521    * Perform a sanity check on the parameters.
 522    */
 523   if ( (This==0) || (pstatstg==0))
 524     return E_INVALIDARG;
 525
 526   /*
 527    * Read the information from the property.
 528    */
 529   readSucessful = Storage32Impl_ReadProperty(
 530                     This->ancestorStorage,
 531                     This->rootPropertySetIndex,
 532                     &curProperty);
 533
 534   if (readSucessful)
 535   {
 536     StorageUtl_CopyPropertyToSTATSTG(
 537       pstatstg,
 538       &curProperty,
 539       grfStatFlag);
 540
 541     return S_OK;
 542   }
 543
 544   return E_FAIL;
 545 }
 546
 547 /************************************************************************
 548  * Storage32BaseImpl_RenameElement (IStorage)
 549  *
 550  * This method will rename the specified element.
 551  *
 552  * See Windows documentation for more details on IStorage methods.
 553  *
 554  * Implementation notes: The method used to rename consists of creating a clone
 555  *    of the deleted StgProperty object setting it with the new name and to
 556  *    perform a DestroyElement of the old StgProperty.
 557  */
 558 HRESULT WINAPI Storage32BaseImpl_RenameElement(
 559             IStorage32*        iface,
 560             const OLECHAR32*   pwcsOldName,  /* [in] */
 561             const OLECHAR32*   pwcsNewName)  /* [in] */
 562 {
 563   ICOM_THIS(Storage32BaseImpl,iface);
 564   IEnumSTATSTGImpl* propertyEnumeration;
 565   StgProperty       currentProperty;
 566   ULONG             foundPropertyIndex;
 567
 568   /*
 569    * Create a property enumeration to search the properties
 570    */
 571   propertyEnumeration = IEnumSTATSTGImpl_Construct(This->ancestorStorage,
 572                                                    This->rootPropertySetIndex);
 573
 574   /*
 575    * Search the enumeration for the new property name
 576    */
 577   foundPropertyIndex = IEnumSTATSTGImpl_FindProperty(propertyEnumeration,
 578                                                      pwcsNewName,
 579                                                      &currentProperty);
 580
 581   if (foundPropertyIndex != PROPERTY_NULL)
 582   {
 583     /*
 584      * There is already a property with the new name
 585      */
 586     IEnumSTATSTGImpl_Destroy(propertyEnumeration);
 587     return STG_E_FILEALREADYEXISTS;
 588   }
 589
 590   IEnumSTATSTGImpl_Reset((IEnumSTATSTG*)propertyEnumeration);
 591
 592   /*
 593    * Search the enumeration for the old property name
 594    */
 595   foundPropertyIndex = IEnumSTATSTGImpl_FindProperty(propertyEnumeration,
 596                                                      pwcsOldName,
 597                                                      &currentProperty);
 598
 599   /*
 600    * Delete the property enumeration since we don't need it anymore
 601    */
 602   IEnumSTATSTGImpl_Destroy(propertyEnumeration);
 603
 604   if (foundPropertyIndex != PROPERTY_NULL)
 605   {
 606     StgProperty renamedProperty;
 607     ULONG       renamedPropertyIndex;
 608
 609     /*
 610      * Setup a new property for the renamed property
 611      */
 612     renamedProperty.sizeOfNameString =
 613       ( lstrlen32W(pwcsNewName)+1 ) * sizeof(WCHAR);
 614
 615     if (renamedProperty.sizeOfNameString > PROPERTY_NAME_BUFFER_LEN)
 616       return STG_E_INVALIDNAME;
 617
 618     lstrcpy32W(renamedProperty.name, pwcsNewName);
 619
 620     renamedProperty.propertyType  = currentProperty.propertyType;
 621     renamedProperty.startingBlock = currentProperty.startingBlock;
 622     renamedProperty.size.LowPart  = currentProperty.size.LowPart;
 623     renamedProperty.size.HighPart = currentProperty.size.HighPart;
 624
 625     renamedProperty.previousProperty = PROPERTY_NULL;
 626     renamedProperty.nextProperty     = PROPERTY_NULL;
 627
 628     /*
 629      * Bring the dirProperty link in case it is a storage and in which
 630      * case the renamed storage elements don't require to be reorganized.
 631      */
 632     renamedProperty.dirProperty = currentProperty.dirProperty;
 633
 634     /* call CoFileTime to get the current time
 635     renamedProperty.timeStampS1
 636     renamedProperty.timeStampD1
 637     renamedProperty.timeStampS2
 638     renamedProperty.timeStampD2
 639     renamedProperty.propertyUniqueID
 640     */
 641
 642     /*
 643      * Obtain a free property in the property chain
 644      */
 645     renamedPropertyIndex = getFreeProperty(This->ancestorStorage);
 646
 647     /*
 648      * Save the new property into the new property spot
 649      */
 650     Storage32Impl_WriteProperty(
 651       This->ancestorStorage,
 652       renamedPropertyIndex,
 653       &renamedProperty);
 654
 655     /*
 656      * Find a spot in the property chain for our newly created property.
 657      */
 658     updatePropertyChain(
 659       (Storage32Impl*)This,
 660       renamedPropertyIndex,
 661       renamedProperty);
 662
 663     /*
 664      * At this point the renamed property has been inserted in the tree,
 665      * now, before to Destroy the old property we must zeroed it's dirProperty
 666      * otherwise the DestroyProperty below will zap it all and we do not want
 667      * this to happen.
 668      * Also, we fake that the old property is a storage so the DestroyProperty
 669      * will not do a SetSize(0) on the stream data.
 670      *
 671      * This means that we need to tweek the StgProperty if it is a stream or a
 672      * non empty storage.
 673      */
 674     currentProperty.dirProperty  = PROPERTY_NULL;
 675     currentProperty.propertyType = PROPTYPE_STORAGE;
 676     Storage32Impl_WriteProperty(
 677       This->ancestorStorage,
 678       foundPropertyIndex,
 679       &currentProperty);
 680
 681     /*
 682      * Invoke Destroy to get rid of the ole property and automatically redo
 683      * the linking of it's previous and next members...
 684      */
 685     Storage32Impl_DestroyElement((IStorage32*)This->ancestorStorage, pwcsOldName);
 686
 687   }
 688   else
 689   {
 690     /*
 691      * There is no property with the old name
 692      */
 693     return STG_E_FILENOTFOUND;
 694   }
 695
 696   return S_OK;
 697 }
 698
 699 /************************************************************************
 700  * Storage32BaseImpl_CreateStream (IStorage)
 701  *
 702  * This method will create a stream object within this storage
 703  *
 704  * See Windows documentation for more details on IStorage methods.
 705  */
 706 HRESULT WINAPI Storage32BaseImpl_CreateStream(
 707             IStorage32*        iface,
 708             const OLECHAR32*   pwcsName,  /* [string][in] */
 709             DWORD              grfMode,   /* [in] */
 710             DWORD              reserved1, /* [in] */
 711             DWORD              reserved2, /* [in] */
 712             IStream32**        ppstm)     /* [out] */
 713 {
 714   ICOM_THIS(Storage32BaseImpl,iface);
 715   IEnumSTATSTGImpl* propertyEnumeration;
 716   StgStreamImpl*    newStream;
 717   StgProperty       currentProperty, newStreamProperty;
 718   ULONG             foundPropertyIndex, newPropertyIndex;
 719
 720   /*
 721    * Validate parameters
 722    */
 723   if (ppstm == 0)
 724     return STG_E_INVALIDPOINTER;
 725
 726   if (pwcsName == 0)
 727     return STG_E_INVALIDNAME;
 728
 729   /*
 730    * Validate the STGM flags
 731    */
 732   if ( FAILED( validateSTGM(grfMode) ))
 733     return STG_E_INVALIDFLAG;
 734
 735   /*
 736    * As documented.
 737    */
 738   if ( !(grfMode & STGM_SHARE_EXCLUSIVE) ||
 739         (grfMode & STGM_DELETEONRELEASE) ||
 740         (grfMode & STGM_TRANSACTED) )
 741     return STG_E_INVALIDFUNCTION;
 742
 743   /*
 744    * Initialize the out parameter
 745    */
 746   *ppstm = 0;
 747
 748   /*
 749    * Create a property enumeration to search the properties
 750    */
 751   propertyEnumeration = IEnumSTATSTGImpl_Construct(This->ancestorStorage,
 752                                                    This->rootPropertySetIndex);
 753
 754   foundPropertyIndex = IEnumSTATSTGImpl_FindProperty(propertyEnumeration,
 755                                                      pwcsName,
 756                                                      &currentProperty);
 757
 758   IEnumSTATSTGImpl_Destroy(propertyEnumeration);
 759
 760   if (foundPropertyIndex != PROPERTY_NULL)
 761   {
 762     /*
 763      * An element with this name already exists
 764      */
 765     if (grfMode & STGM_CREATE)
 766       Storage32Impl_DestroyElement((IStorage32*)This->ancestorStorage, pwcsName);
 767     else
 768       return STG_E_FILEALREADYEXISTS;
 769   }
 770
 771   /*
 772    * memset the empty property
 773    */
 774   memset(&newStreamProperty, 0, sizeof(StgProperty));
 775
 776   newStreamProperty.sizeOfNameString =
 777       ( lstrlen32W(pwcsName)+1 ) * sizeof(WCHAR);
 778
 779   if (newStreamProperty.sizeOfNameString > PROPERTY_NAME_BUFFER_LEN)
 780     return STG_E_INVALIDNAME;
 781
 782   lstrcpy32W(newStreamProperty.name, pwcsName);
 783
 784   newStreamProperty.propertyType  = PROPTYPE_STREAM;
 785   newStreamProperty.startingBlock = BLOCK_END_OF_CHAIN;
 786   newStreamProperty.size.LowPart  = 0;
 787   newStreamProperty.size.HighPart = 0;
 788
 789   newStreamProperty.previousProperty = PROPERTY_NULL;
 790   newStreamProperty.nextProperty     = PROPERTY_NULL;
 791   newStreamProperty.dirProperty      = PROPERTY_NULL;
 792
 793   /* call CoFileTime to get the current time
 794   newStreamProperty.timeStampS1
 795   newStreamProperty.timeStampD1
 796   newStreamProperty.timeStampS2
 797   newStreamProperty.timeStampD2
 798   */
 799
 800   /*  newStreamProperty.propertyUniqueID */
 801
 802   /*
 803    * Get a free property or create a new one
 804    */
 805   newPropertyIndex = getFreeProperty(This->ancestorStorage);
 806
 807   /*
 808    * Save the new property into the new property spot
 809    */
 810   Storage32Impl_WriteProperty(
 811     This->ancestorStorage,
 812     newPropertyIndex,
 813     &newStreamProperty);
 814
 815   /*
 816    * Find a spot in the property chain for our newly created property.
 817    */
 818   updatePropertyChain(
 819     (Storage32Impl*)This,
 820     newPropertyIndex,
 821     newStreamProperty);
 822
 823   /*
 824    * Open the stream to return it.
 825    */
 826   newStream = StgStreamImpl_Construct(This, newPropertyIndex);
 827
 828   if (newStream != 0)
 829   {
 830     *ppstm = (IStream32*)newStream;
 831
 832     /*
 833      * Since we are returning a pointer to the interface, we have to nail down
 834      * the reference.
 835      */
 836     StgStreamImpl_AddRef(*ppstm);
 837   }
 838   else
 839   {
 840     return STG_E_INSUFFICIENTMEMORY;
 841   }
 842
 843   return S_OK;
 844 }
 845
 846 /************************************************************************
 847  * Storage32BaseImpl_SetClass (IStorage)
 848  *
 849  * This method will write the specified CLSID in the property of this
 850  * storage.
 851  *
 852  * See Windows documentation for more details on IStorage methods.
 853  */
 854 HRESULT WINAPI Storage32BaseImpl_SetClass(
 855   IStorage32*        iface,
 856   REFCLSID           clsid) /* [in] */
 857 {
 858   ICOM_THIS(Storage32BaseImpl,iface);
 859   HRESULT hRes = E_FAIL;
 860   StgProperty curProperty;
 861   BOOL32 success;
 862
 863   success = Storage32Impl_ReadProperty(This->ancestorStorage,
 864                                        This->rootPropertySetIndex,
 865                                        &curProperty);
 866   if (success)
 867   {
 868     curProperty.propertyUniqueID = *clsid;
 869
 870     success =  Storage32Impl_WriteProperty(This->ancestorStorage,
 871                                            This->rootPropertySetIndex,
 872                                            &curProperty);
 873     if (success)
 874       hRes = S_OK;
 875   }
 876
 877   return hRes;
 878 }
 879
 880 /************************************************************************
 881 ** Storage32Impl implementation
 882 */
 883
 884 /************************************************************************
 885  * Storage32Impl_CreateStorage (IStorage)
 886  *
 887  * This method will create the storage object within the provided storage.
 888  *
 889  * See Windows documentation for more details on IStorage methods.
 890  */
 891 HRESULT WINAPI Storage32Impl_CreateStorage(
 892   IStorage32*      iface,
 893   const OLECHAR32  *pwcsName, /* [string][in] */
 894   DWORD            grfMode,   /* [in] */
 895   DWORD            reserved1, /* [in] */
 896   DWORD            reserved2, /* [in] */
 897   IStorage32       **ppstg)   /* [out] */
 898 {
 899   Storage32Impl* const This=(Storage32Impl*)iface;
 900
 901   IEnumSTATSTGImpl *propertyEnumeration;
 902   StgProperty      currentProperty;
 903   StgProperty      newProperty;
 904   ULONG            foundPropertyIndex;
 905   ULONG            newPropertyIndex;
 906   HRESULT          hr;
 907
 908   /*
 909    * Validate parameters
 910    */
 911   if (ppstg == 0)
 912     return STG_E_INVALIDPOINTER;
 913
 914   if (pwcsName == 0)
 915     return STG_E_INVALIDNAME;
 916
 917   /*
 918    * Validate the STGM flags
 919    */
 920   if ( FAILED( validateSTGM(grfMode) ) ||
 921        (grfMode & STGM_DELETEONRELEASE) )
 922     return STG_E_INVALIDFLAG;
 923
 924   /*
 925    * Initialize the out parameter
 926    */
 927   *ppstg = 0;
 928
 929   /*
 930    * Create a property enumeration and search the properties
 931    */
 932   propertyEnumeration = IEnumSTATSTGImpl_Construct( This->ancestorStorage,
 933                                                     This->rootPropertySetIndex);
 934
 935   foundPropertyIndex = IEnumSTATSTGImpl_FindProperty(propertyEnumeration,
 936                                                      pwcsName,
 937                                                      &currentProperty);
 938   IEnumSTATSTGImpl_Destroy(propertyEnumeration);
 939
 940   if (foundPropertyIndex != PROPERTY_NULL)
 941   {
 942     /*
 943      * An element with this name already exists
 944      */
 945     if (grfMode & STGM_CREATE)
 946       Storage32Impl_DestroyElement((IStorage32*)This->ancestorStorage, pwcsName);
 947     else
 948       return STG_E_FILEALREADYEXISTS;
 949   }
 950
 951   /*
 952    * memset the empty property
 953    */
 954   memset(&newProperty, 0, sizeof(StgProperty));
 955
 956   newProperty.sizeOfNameString = (lstrlen32W(pwcsName)+1)*sizeof(WCHAR);
 957
 958   if (newProperty.sizeOfNameString > PROPERTY_NAME_BUFFER_LEN)
 959     return STG_E_INVALIDNAME;
 960
 961   lstrcpy32W(newProperty.name, pwcsName);
 962
 963   newProperty.propertyType  = PROPTYPE_STORAGE;
 964   newProperty.startingBlock = BLOCK_END_OF_CHAIN;
 965   newProperty.size.LowPart  = 0;
 966   newProperty.size.HighPart = 0;
 967
 968   newProperty.previousProperty = PROPERTY_NULL;
 969   newProperty.nextProperty     = PROPERTY_NULL;
 970   newProperty.dirProperty      = PROPERTY_NULL;
 971
 972   /* call CoFileTime to get the current time
 973   newProperty.timeStampS1
 974   newProperty.timeStampD1
 975   newProperty.timeStampS2
 976   newProperty.timeStampD2
 977   */
 978
 979   /*  newStorageProperty.propertyUniqueID */
 980
 981   /*
 982    * Obtain a free property in the property chain
 983    */
 984   newPropertyIndex = getFreeProperty(This->ancestorStorage);
 985
 986   /*
 987    * Save the new property into the new property spot
 988    */
 989   Storage32Impl_WriteProperty(
 990     This->ancestorStorage,
 991     newPropertyIndex,
 992     &newProperty);
 993
 994   /*
 995    * Find a spot in the property chain for our newly created property.
 996    */
 997   updatePropertyChain(
 998     This,
 999     newPropertyIndex,
1000     newProperty);
1001
1002   /*
1003    * Open it to get a pointer to return.
1004    */
1005   hr = Storage32BaseImpl_OpenStorage(
1006          iface,
1007          (OLECHAR32*)pwcsName,
1008          0,
1009          grfMode,
1010          0,
1011          0,
1012          ppstg);
1013
1014   if( (hr != S_OK) || (*ppstg == NULL))
1015   {
1016     return hr;
1017   }
1018
1019   return S_OK;
1020 }
1021
1022
1023 /***************************************************************************
1024  *
1025  * Internal Method
1026  *
1027  * Get a free property or create a new one.
1028  */
1029 static ULONG getFreeProperty(
1030   Storage32Impl *storage)
1031 {
1032   ULONG       currentPropertyIndex = 0;
1033   ULONG       newPropertyIndex     = PROPERTY_NULL;
1034   BOOL32      readSucessful        = TRUE;
1035   StgProperty currentProperty;
1036
1037   do
1038   {
1039     /*
1040      * Start by reading the root property
1041      */
1042     readSucessful = Storage32Impl_ReadProperty(storage->ancestorStorage,
1043                                                currentPropertyIndex,
1044                                                &currentProperty);
1045     if (readSucessful)
1046     {
1047       if (currentProperty.sizeOfNameString == 0)
1048       {
1049         /*
1050          * The property existis and is available, we found it.
1051          */
1052         newPropertyIndex = currentPropertyIndex;
1053       }
1054     }
1055     else
1056     {
1057       /*
1058        * We exhausted the property list, we will create more space below
1059        */
1060       newPropertyIndex = currentPropertyIndex;
1061     }
1062     currentPropertyIndex++;
1063
1064   } while (newPropertyIndex == PROPERTY_NULL);
1065
1066   /*
1067    * grow the property chain
1068    */
1069   if (! readSucessful)
1070   {
1071     StgProperty    emptyProperty;
1072     ULARGE_INTEGER newSize;
1073     ULONG          propertyIndex;
1074     ULONG          lastProperty  = 0;
1075     ULONG          blockCount    = 0;
1076
1077     /*
1078      * obtain the new count of property blocks
1079      */
1080     blockCount = BlockChainStream_GetCount(
1081                    storage->ancestorStorage->rootBlockChain)+1;
1082
1083     /*
1084      * initialize the size used by the property stream
1085      */
1086     newSize.HighPart = 0;
1087     newSize.LowPart  = storage->bigBlockSize * blockCount;
1088
1089     /*
1090      * add a property block to the property chain
1091      */
1092     BlockChainStream_SetSize(storage->ancestorStorage->rootBlockChain, newSize);
1093
1094     /*
1095      * memset the empty property in order to initialize the unused newly
1096      * created property
1097      */
1098     memset(&emptyProperty, 0, sizeof(StgProperty));
1099
1100     /*
1101      * initialize them
1102      */
1103     lastProperty = storage->bigBlockSize / PROPSET_BLOCK_SIZE * blockCount;
1104
1105     for(
1106       propertyIndex = newPropertyIndex;
1107       propertyIndex < lastProperty;
1108       propertyIndex++)
1109     {
1110       Storage32Impl_WriteProperty(
1111         storage->ancestorStorage,
1112         propertyIndex,
1113         &emptyProperty);
1114     }
1115   }
1116
1117   return newPropertyIndex;
1118 }
1119
1120 /****************************************************************************
1121  *
1122  * Internal Method
1123  *
1124  * Case insensitive comparaison of StgProperty.name by first considering
1125  * their size.
1126  *
1127  * Returns <0 when newPrpoerty < currentProperty
1128  *         >0 when newPrpoerty > currentProperty
1129  *          0 when newPrpoerty == currentProperty
1130  */
1131 static LONG propertyNameCmp(
1132   OLECHAR32 *newProperty,
1133   OLECHAR32 *currentProperty)
1134 {
1135   LONG sizeOfNew = (lstrlen32W(newProperty)    +1) * sizeof(WCHAR);
1136   LONG sizeOfCur = (lstrlen32W(currentProperty)+1) * sizeof(WCHAR);
1137   LONG diff      = sizeOfNew - sizeOfCur;
1138
1139   if (diff == 0)
1140   {
1141     /*
1142      * We compare the string themselves only when they are of the same lenght
1143      */
1144     WCHAR wsnew[PROPERTY_NAME_MAX_LEN];
1145     WCHAR wscur[PROPERTY_NAME_MAX_LEN];
1146
1147     diff = lstrcmp32W( (LPCWSTR)CRTDLL__wcsupr(
1148                            lstrcpyn32W(wsnew, newProperty, sizeOfNew)),
1149                        (LPCWSTR)CRTDLL__wcsupr(
1150                            lstrcpyn32W(wscur, currentProperty, sizeOfCur)));
1151   }
1152
1153   return diff;
1154 }
1155
1156 /****************************************************************************
1157  *
1158  * Internal Method
1159  *
1160  * Properly link this new element in the property chain.
1161  */
1162 static void updatePropertyChain(
1163   Storage32Impl *storage,
1164   ULONG         newPropertyIndex,
1165   StgProperty   newProperty)
1166 {
1167   StgProperty currentProperty;
1168
1169   /*
1170    * Read the root property
1171    */
1172   Storage32Impl_ReadProperty(storage->ancestorStorage,
1173                              storage->rootPropertySetIndex,
1174                              &currentProperty);
1175
1176   if (currentProperty.dirProperty != PROPERTY_NULL)
1177   {
1178     /*
1179      * The root storage contains some element, therefore, start the research
1180      * for the appropriate location.
1181      */
1182     BOOL32 found = 0;
1183     ULONG  current, next, previous, currentPropertyId;
1184
1185     /*
1186      * Keep the StgProperty sequence number of the storage first property
1187      */
1188     currentPropertyId = currentProperty.dirProperty;
1189
1190     /*
1191      * Read
1192      */
1193     Storage32Impl_ReadProperty(storage->ancestorStorage,
1194                                currentProperty.dirProperty,
1195                                &currentProperty);
1196
1197     previous = currentProperty.previousProperty;
1198     next     = currentProperty.nextProperty;
1199     current  = currentPropertyId;
1200
1201     while (found == 0)
1202     {
1203       LONG diff = propertyNameCmp( newProperty.name, currentProperty.name);
1204
1205       if (diff < 0)
1206       {
1207         if (previous != PROPERTY_NULL)
1208         {
1209           Storage32Impl_ReadProperty(storage->ancestorStorage,
1210                                      previous,
1211                                      &currentProperty);
1212           current = previous;
1213         }
1214         else
1215         {
1216           currentProperty.previousProperty = newPropertyIndex;
1217           Storage32Impl_WriteProperty(storage->ancestorStorage,
1218                                       current,
1219                                       &currentProperty);
1220           found = 1;
1221         }
1222       }
1223       else
1224       {
1225         if (next != PROPERTY_NULL)
1226         {
1227           Storage32Impl_ReadProperty(storage->ancestorStorage,
1228                                      next,
1229                                      &currentProperty);
1230           current = next;
1231         }
1232         else
1233         {
1234           currentProperty.nextProperty = newPropertyIndex;
1235           Storage32Impl_WriteProperty(storage->ancestorStorage,
1236                                       current,
1237                                       &currentProperty);
1238           found = 1;
1239         }
1240       }
1241
1242       previous = currentProperty.previousProperty;
1243       next     = currentProperty.nextProperty;
1244     }
1245   }
1246   else
1247   {
1248     /*
1249      * The root storage is empty, link the new property to it's dir property
1250      */
1251     currentProperty.dirProperty = newPropertyIndex;
1252     Storage32Impl_WriteProperty(storage->ancestorStorage,
1253                                 storage->rootPropertySetIndex,
1254                                 &currentProperty);
1255   }
1256 }
1257
1258
1259 /*************************************************************************
1260  * CopyTo (IStorage)
1261  */
1262 HRESULT WINAPI Storage32Impl_CopyTo(
1263   IStorage32*   iface,
1264   DWORD         ciidExclude,  /* [in] */
1265   const IID     *rgiidExclude,/* [size_is][unique][in] */
1266   SNB32         snbExclude,   /* [unique][in] */
1267   IStorage32    *pstgDest)    /* [unique][in] */
1268 {
1269   return E_NOTIMPL;
1270 }
1271
1272 /*************************************************************************
1273  * MoveElementTo (IStorage)
1274  */
1275 HRESULT WINAPI Storage32Impl_MoveElementTo(
1276   IStorage32*     iface,
1277   const OLECHAR32 *pwcsName,   /* [string][in] */
1278   IStorage32      *pstgDest,   /* [unique][in] */
1279   const OLECHAR32 *pwcsNewName,/* [string][in] */
1280   DWORD           grfFlags)    /* [in] */
1281 {
1282   return E_NOTIMPL;
1283 }
1284
1285 /*************************************************************************
1286  * Commit (IStorage)
1287  */
1288 HRESULT WINAPI Storage32Impl_Commit(
1289   IStorage32*   iface,
1290   DWORD         grfCommitFlags)/* [in] */
1291 {
1292   FIXME(ole, "(%ld): stub!\n", grfCommitFlags);
1293   return S_OK;
1294 }
1295
1296 /*************************************************************************
1297  * Revert (IStorage)
1298  */
1299 HRESULT WINAPI Storage32Impl_Revert(
1300   IStorage32* iface)
1301 {
1302   return E_NOTIMPL;
1303 }
1304
1305 /*************************************************************************
1306  * DestroyElement (IStorage)
1307  *
1308  * Stategy: This implementation is build this way for simplicity not for speed.
1309  *          I always delete the top most element of the enumeration and adjust
1310  *          the deleted element pointer all the time.  This takes longer to
1311  *          do but allow to reinvoke DestroyElement whenever we encounter a
1312  *          storage object.  The optimisation reside in the usage of another
1313  *          enumeration stategy that would give all the leaves of a storage
1314  *          first. (postfix order)
1315  */
1316 HRESULT WINAPI Storage32Impl_DestroyElement(
1317   IStorage32*     iface,
1318   const OLECHAR32 *pwcsName)/* [string][in] */
1319 {
1320   Storage32Impl* const This=(Storage32Impl*)iface;
1321
1322   IEnumSTATSTGImpl* propertyEnumeration;
1323   HRESULT           hr = S_OK;
1324   BOOL32            res;
1325   StgProperty       propertyToDelete;
1326   StgProperty       parentProperty;
1327   ULONG             foundPropertyIndexToDelete;
1328   ULONG             typeOfRelation;
1329   ULONG             parentPropertyId;
1330
1331   /*
1332    * Perform a sanity check on the parameters.
1333    */
1334   if (pwcsName==NULL)
1335     return STG_E_INVALIDPOINTER;
1336
1337   /*
1338    * Create a property enumeration to search the property with the given name
1339    */
1340   propertyEnumeration = IEnumSTATSTGImpl_Construct(
1341     This->ancestorStorage,
1342     This->rootPropertySetIndex);
1343
1344   foundPropertyIndexToDelete = IEnumSTATSTGImpl_FindProperty(
1345     propertyEnumeration,
1346     pwcsName,
1347     &propertyToDelete);
1348
1349   IEnumSTATSTGImpl_Destroy(propertyEnumeration);
1350
1351   if ( foundPropertyIndexToDelete == PROPERTY_NULL )
1352   {
1353     return STG_E_FILENOTFOUND;
1354   }
1355
1356   /*
1357    * Find the parent property of the property to delete (the one that
1358    * link to it).  If This->dirProperty == foundPropertyIndexToDelete,
1359    * the parent is This. Otherwise, the parent is one of it's sibling...
1360    */
1361
1362   /*
1363    * First, read This's StgProperty..
1364    */
1365   res = Storage32Impl_ReadProperty(
1366           This->ancestorStorage,
1367           This->rootPropertySetIndex,
1368           &parentProperty);
1369
1370   assert(res==TRUE);
1371
1372   /*
1373    * Second, check to see if by any chance the actual storage (This) is not
1374    * the parent of the property to delete... We never know...
1375    */
1376   if ( parentProperty.dirProperty == foundPropertyIndexToDelete )
1377   {
1378     /*
1379      * Set data as it would have been done in the else part...
1380      */
1381     typeOfRelation   = PROPERTY_RELATION_DIR;
1382     parentPropertyId = This->rootPropertySetIndex;
1383   }
1384   else
1385   {
1386     /*
1387      * Create a property enumeration to search the parent properties, and
1388      * delete it once done.
1389      */
1390     IEnumSTATSTGImpl* propertyEnumeration2;
1391
1392     propertyEnumeration2 = IEnumSTATSTGImpl_Construct(
1393       This->ancestorStorage,
1394       This->rootPropertySetIndex);
1395
1396     typeOfRelation = IEnumSTATSTGImpl_FindParentProperty(
1397       propertyEnumeration2,
1398       foundPropertyIndexToDelete,
1399       &parentProperty,
1400       &parentPropertyId);
1401
1402     IEnumSTATSTGImpl_Destroy(propertyEnumeration2);
1403   }
1404
1405   if ( propertyToDelete.propertyType == PROPTYPE_STORAGE )
1406   {
1407     hr = deleteStorageProperty(
1408            This,
1409            propertyToDelete.name);
1410   }
1411   else if ( propertyToDelete.propertyType == PROPTYPE_STREAM )
1412   {
1413     hr = deleteStreamProperty(
1414            This,
1415            foundPropertyIndexToDelete,
1416            propertyToDelete);
1417   }
1418
1419   if (hr!=S_OK)
1420     return hr;
1421
1422   /*
1423    * Adjust the property chain
1424    */
1425   hr = adjustPropertyChain(
1426         This,
1427         propertyToDelete,
1428         parentProperty,
1429         parentPropertyId,
1430         typeOfRelation);
1431
1432   return hr;
1433 }
1434
1435
1436 /*********************************************************************
1437  *
1438  * Internal Method
1439  *
1440  * Perform the deletion of a complete storage node
1441  *
1442  */
1443 static HRESULT deleteStorageProperty(
1444   Storage32Impl *parentStorage,
1445   OLECHAR32     *propertyToDeleteName)
1446 {
1447   IEnumSTATSTG *elements     = 0;
1448   IStorage32   *childStorage = 0;
1449   STATSTG      currentElement;
1450   HRESULT      hr;
1451   HRESULT      destroyHr = S_OK;
1452
1453   /*
1454    * Open the storage and enumerate it
1455    */
1456   hr = Storage32BaseImpl_OpenStorage(
1457         (IStorage32*)parentStorage,
1458         propertyToDeleteName,
1459         0,
1460         STGM_SHARE_EXCLUSIVE,
1461         0,
1462         0,
1463         &childStorage);
1464
1465   if (hr != S_OK)
1466   {
1467     return hr;
1468   }
1469
1470   /*
1471    * Enumerate the elements
1472    */
1473   IStorage32_EnumElements( childStorage, 0, 0, 0, &elements);
1474
1475   do
1476   {
1477     /*
1478      * Obtain the next element
1479      */
1480     hr = IEnumSTATSTG_Next(elements, 1, &currentElement, NULL);
1481     if (hr==S_OK)
1482     {
1483       destroyHr = Storage32Impl_DestroyElement(
1484                     (IStorage32*)childStorage,
1485                     (OLECHAR32*)currentElement.pwcsName);
1486
1487       CoTaskMemFree(currentElement.pwcsName);
1488     }
1489
1490     /*
1491      * We need to Reset the enumeration every time because we delete elements
1492      * and the enumeration could be invalid
1493      */
1494     IEnumSTATSTG_Reset(elements);
1495
1496   } while ((hr == S_OK) && (destroyHr == S_OK));
1497
1498   IStorage32_Release(childStorage);
1499   IEnumSTATSTG_Release(elements);
1500
1501   return destroyHr;
1502 }
1503
1504 /*********************************************************************
1505  *
1506  * Internal Method
1507  *
1508  * Perform the deletion of a stream node
1509  *
1510  */
1511 static HRESULT deleteStreamProperty(
1512   Storage32Impl *parentStorage,
1513   ULONG         indexOfPropertyToDelete,
1514   StgProperty   propertyToDelete)
1515 {
1516   IStream32      *pis;
1517   HRESULT        hr;
1518   ULARGE_INTEGER size;
1519
1520   size.HighPart = 0;
1521   size.LowPart = 0;
1522
1523   hr = Storage32BaseImpl_OpenStream(
1524          (IStorage32*)parentStorage,
1525          (OLECHAR32*)propertyToDelete.name,
1526          NULL,
1527          STGM_SHARE_EXCLUSIVE,
1528          0,
1529          &pis);
1530
1531   if (hr!=S_OK)
1532   {
1533     return(hr);
1534   }
1535
1536   /*
1537    * Zap the stream
1538    */
1539   hr = IStream32_SetSize(pis, size);
1540
1541   if(hr != S_OK)
1542   {
1543     return hr;
1544   }
1545
1546   /*
1547    * Invalidate the property by zeroing it's name member.
1548    */
1549   propertyToDelete.sizeOfNameString = 0;
1550
1551   /*
1552    * Here we should re-read the property so we get the updated pointer
1553    * but since we are here to zap it, I don't do it...
1554    */
1555
1556   Storage32Impl_WriteProperty(
1557     parentStorage->ancestorStorage,
1558     indexOfPropertyToDelete,
1559     &propertyToDelete);
1560
1561   return S_OK;
1562 }
1563
1564 /*********************************************************************
1565  *
1566  * Internal Method
1567  *
1568  * Finds a placeholder for the StgProperty within the Storage
1569  *
1570  */
1571 static HRESULT findPlaceholder(
1572   Storage32Impl *storage,
1573   ULONG         propertyIndexToStore,
1574   ULONG         storePropertyIndex,
1575   INT32         typeOfRelation)
1576 {
1577   StgProperty storeProperty;
1578   HRESULT     hr = S_OK;
1579   BOOL32      res = TRUE;
1580
1581   /*
1582    * Read the storage property
1583    */
1584   res = Storage32Impl_ReadProperty(
1585           storage->ancestorStorage,
1586           storePropertyIndex,
1587           &storeProperty);
1588
1589   if(! res)
1590   {
1591     return E_FAIL;
1592   }
1593
1594   if (typeOfRelation == PROPERTY_RELATION_PREVIOUS)
1595   {
1596     if (storeProperty.previousProperty != PROPERTY_NULL)
1597     {
1598       return findPlaceholder(
1599                storage,
1600                propertyIndexToStore,
1601                storeProperty.previousProperty,
1602                typeOfRelation);
1603     }
1604     else
1605     {
1606       storeProperty.previousProperty = propertyIndexToStore;
1607     }
1608   }
1609   else if (typeOfRelation == PROPERTY_RELATION_NEXT)
1610   {
1611     if (storeProperty.nextProperty != PROPERTY_NULL)
1612     {
1613       return findPlaceholder(
1614                storage,
1615                propertyIndexToStore,
1616                storeProperty.nextProperty,
1617                typeOfRelation);
1618     }
1619     else
1620     {
1621       storeProperty.nextProperty = propertyIndexToStore;
1622     }
1623   }
1624   else if (typeOfRelation == PROPERTY_RELATION_DIR)
1625   {
1626     if (storeProperty.dirProperty != PROPERTY_NULL)
1627     {
1628       return findPlaceholder(
1629                storage,
1630                propertyIndexToStore,
1631                storeProperty.dirProperty,
1632                typeOfRelation);
1633     }
1634     else
1635     {
1636       storeProperty.dirProperty = propertyIndexToStore;
1637     }
1638   }
1639
1640   hr = Storage32Impl_WriteProperty(
1641          storage->ancestorStorage,
1642          storePropertyIndex,
1643          &storeProperty);
1644
1645   if(! hr)
1646   {
1647     return E_FAIL;
1648   }
1649
1650   return S_OK;
1651 }
1652
1653 /*************************************************************************
1654  *
1655  * Internal Method
1656  *
1657  * This method takes the previous and the next property link of a property
1658  * to be deleted and find them a place in the Storage.
1659  */
1660 static HRESULT adjustPropertyChain(
1661   Storage32Impl *This,
1662   StgProperty   propertyToDelete,
1663   StgProperty   parentProperty,
1664   ULONG         parentPropertyId,
1665   INT32         typeOfRelation)
1666 {
1667   ULONG   newLinkProperty        = PROPERTY_NULL;
1668   BOOL32  needToFindAPlaceholder = FALSE;
1669   ULONG   storeNode              = PROPERTY_NULL;
1670   ULONG   toStoreNode            = PROPERTY_NULL;
1671   INT32   relationType           = 0;
1672   HRESULT hr                     = S_OK;
1673   BOOL32  res                    = TRUE;
1674
1675   if (typeOfRelation == PROPERTY_RELATION_PREVIOUS)
1676   {
1677     if (propertyToDelete.previousProperty != PROPERTY_NULL)
1678     {
1679       /*
1680        * Set the parent previous to the property to delete previous
1681        */
1682       newLinkProperty = propertyToDelete.previousProperty;
1683
1684       if (propertyToDelete.nextProperty != PROPERTY_NULL)
1685       {
1686         /*
1687          * We also need to find a storage for the other link, setup variables
1688          * to do this at the end...
1689          */
1690         needToFindAPlaceholder = TRUE;
1691         storeNode              = propertyToDelete.previousProperty;
1692         toStoreNode            = propertyToDelete.nextProperty;
1693         relationType           = PROPERTY_RELATION_NEXT;
1694       }
1695     }
1696     else if (propertyToDelete.nextProperty != PROPERTY_NULL)
1697     {
1698       /*
1699        * Set the parent previous to the property to delete next
1700        */
1701       newLinkProperty = propertyToDelete.nextProperty;
1702     }
1703
1704     /*
1705      * Link it for real...
1706      */
1707     parentProperty.previousProperty = newLinkProperty;
1708
1709   }
1710   else if (typeOfRelation == PROPERTY_RELATION_NEXT)
1711   {
1712     if (propertyToDelete.previousProperty != PROPERTY_NULL)
1713     {
1714       /*
1715        * Set the parent next to the property to delete next previous
1716        */
1717       newLinkProperty = propertyToDelete.previousProperty;
1718
1719       if (propertyToDelete.nextProperty != PROPERTY_NULL)
1720       {
1721         /*
1722          * We also need to find a storage for the other link, setup variables
1723          * to do this at the end...
1724          */
1725         needToFindAPlaceholder = TRUE;
1726         storeNode              = propertyToDelete.previousProperty;
1727         toStoreNode            = propertyToDelete.nextProperty;
1728         relationType           = PROPERTY_RELATION_NEXT;
1729       }
1730     }
1731     else if (propertyToDelete.nextProperty != PROPERTY_NULL)
1732     {
1733       /*
1734        * Set the parent next to the property to delete next
1735        */
1736       newLinkProperty = propertyToDelete.nextProperty;
1737     }
1738
1739     /*
1740      * Link it for real...
1741      */
1742     parentProperty.nextProperty = newLinkProperty;
1743   }
1744   else /* (typeOfRelation == PROPERTY_RELATION_DIR) */
1745   {
1746     if (propertyToDelete.previousProperty != PROPERTY_NULL)
1747     {
1748       /*
1749        * Set the parent dir to the property to delete previous
1750        */
1751       newLinkProperty = propertyToDelete.previousProperty;
1752
1753       if (propertyToDelete.nextProperty != PROPERTY_NULL)
1754       {
1755         /*
1756          * We also need to find a storage for the other link, setup variables
1757          * to do this at the end...
1758          */
1759         needToFindAPlaceholder = TRUE;
1760         storeNode              = propertyToDelete.previousProperty;
1761         toStoreNode            = propertyToDelete.nextProperty;
1762         relationType           = PROPERTY_RELATION_NEXT;
1763       }
1764     }
1765     else if (propertyToDelete.nextProperty != PROPERTY_NULL)
1766     {
1767       /*
1768        * Set the parent dir to the property to delete next
1769        */
1770       newLinkProperty = propertyToDelete.nextProperty;
1771     }
1772
1773     /*
1774      * Link it for real...
1775      */
1776     parentProperty.dirProperty = newLinkProperty;
1777   }
1778
1779   /*
1780    * Write back the parent property
1781    */
1782   res = Storage32Impl_WriteProperty(
1783           This->ancestorStorage,
1784           parentPropertyId,
1785           &parentProperty);
1786   if(! res)
1787   {
1788     return E_FAIL;
1789   }
1790
1791   /*
1792    * If a placeholder is required for the other link, then, find one and
1793    * get out of here...
1794    */
1795   if (needToFindAPlaceholder)
1796   {
1797     hr = findPlaceholder(
1798            This,
1799            toStoreNode,
1800            storeNode,
1801            relationType);
1802   }
1803
1804   return hr;
1805 }
1806
1807
1808 /******************************************************************************
1809  * SetElementTimes (IStorage)
1810  */
1811 HRESULT WINAPI Storage32Impl_SetElementTimes(
1812   IStorage32*     iface,
1813   const OLECHAR32 *pwcsName,/* [string][in] */
1814   const FILETIME  *pctime,  /* [in] */
1815   const FILETIME  *patime,  /* [in] */
1816   const FILETIME  *pmtime)  /* [in] */
1817 {
1818   return E_NOTIMPL;
1819 }
1820
1821 /******************************************************************************
1822  * SetStateBits (IStorage)
1823  */
1824 HRESULT WINAPI Storage32Impl_SetStateBits(
1825   IStorage32*   iface,
1826   DWORD         grfStateBits,/* [in] */
1827   DWORD         grfMask)     /* [in] */
1828 {
1829   return E_NOTIMPL;
1830 }
1831
1832 HRESULT Storage32Impl_Construct(
1833   Storage32Impl* This,
1834   HANDLE32       hFile,
1835   DWORD          openFlags)
1836 {
1837   HRESULT     hr = S_OK;
1838   StgProperty currentProperty;
1839   BOOL32      readSucessful;
1840   ULONG       currentPropertyIndex;
1841
1842   if ( FAILED( validateSTGM(openFlags) ))
1843     return STG_E_INVALIDFLAG;
1844
1845   memset(This, 0, sizeof(Storage32Impl));
1846
1847   /*
1848    * Initialize the virtual fgunction table.
1849    */
1850   This->lpvtbl       = &Storage32Impl_Vtbl;
1851   This->v_destructor = &Storage32Impl_Destroy;
1852
1853   /*
1854    * This is the top-level storage so initialize the ancester pointer
1855    * to this.
1856    */
1857   This->ancestorStorage = This;
1858
1859   /*
1860    * Initialize the physical support of the storage.
1861    */
1862   This->hFile = hFile;
1863
1864   /*
1865    * Initialize the big block cache.
1866    */
1867   This->bigBlockSize   = DEF_BIG_BLOCK_SIZE;
1868   This->smallBlockSize = DEF_SMALL_BLOCK_SIZE;
1869   This->bigBlockFile   = BIGBLOCKFILE_Construct(hFile,
1870                                                 openFlags,
1871                                                 This->bigBlockSize);
1872
1873   if (This->bigBlockFile == 0)
1874     return E_FAIL;
1875
1876   if (openFlags & STGM_CREATE)
1877   {
1878     ULARGE_INTEGER size;
1879     BYTE* bigBlockBuffer;
1880
1881     /*
1882      * Initialize all header variables:
1883      * - The big block depot consists of one block and it is at block 0
1884      * - The properties start at block 1
1885      * - There is no small block depot
1886      */
1887     memset( This->bigBlockDepotStart,
1888             BLOCK_UNUSED,
1889             sizeof(This->bigBlockDepotStart));
1890
1891     This->bigBlockDepotCount    = 1;
1892     This->bigBlockDepotStart[0] = 0;
1893     This->rootStartBlock        = 1;
1894     This->smallBlockDepotStart  = BLOCK_END_OF_CHAIN;
1895     This->bigBlockSizeBits      = DEF_BIG_BLOCK_SIZE_BITS;
1896     This->smallBlockSizeBits    = DEF_SMALL_BLOCK_SIZE_BITS;
1897     This->extBigBlockDepotStart = BLOCK_END_OF_CHAIN;
1898     This->extBigBlockDepotCount = 0;
1899
1900     Storage32Impl_SaveFileHeader(This);
1901
1902     /*
1903      * Add one block for the big block depot and one block for the properties
1904      */
1905     size.HighPart = 0;
1906     size.LowPart  = This->bigBlockSize * 3;
1907     BIGBLOCKFILE_SetSize(This->bigBlockFile, size);
1908
1909     /*
1910      * Initialize the big block depot
1911      */
1912     bigBlockBuffer = Storage32Impl_GetBigBlock(This, 0);
1913     memset(bigBlockBuffer, BLOCK_UNUSED, This->bigBlockSize);
1914     StorageUtl_WriteDWord(bigBlockBuffer, 0, BLOCK_SPECIAL);
1915     StorageUtl_WriteDWord(bigBlockBuffer, sizeof(ULONG), BLOCK_END_OF_CHAIN);
1916     Storage32Impl_ReleaseBigBlock(This, bigBlockBuffer);
1917   }
1918   else
1919   {
1920     /*
1921      * Load the header for the file.
1922      */
1923     Storage32Impl_LoadFileHeader(This);
1924   }
1925
1926   /*
1927    * There is no block depot cached yet.
1928    */
1929   This->indexBlockDepotCached = 0xFFFFFFFF;
1930
1931   /*
1932    * Create the block chain abstractions.
1933    */
1934   This->rootBlockChain =
1935     BlockChainStream_Construct(This, &This->rootStartBlock, PROPERTY_NULL);
1936
1937   This->smallBlockDepotChain = BlockChainStream_Construct(
1938                                  This,
1939                                  &This->smallBlockDepotStart,
1940                                  PROPERTY_NULL);
1941
1942   /*
1943    * Write the root property
1944    */
1945   if (openFlags & STGM_CREATE)
1946   {
1947     StgProperty rootProp;
1948     /*
1949      * Initialize the property chain
1950      */
1951     memset(&rootProp, 0, sizeof(rootProp));
1952     lstrcpyAtoW(rootProp.name, rootPropertyName);
1953
1954     rootProp.sizeOfNameString = (lstrlen32W(rootProp.name)+1) * sizeof(WCHAR);
1955     rootProp.propertyType     = PROPTYPE_ROOT;
1956     rootProp.previousProperty = PROPERTY_NULL;
1957     rootProp.nextProperty     = PROPERTY_NULL;
1958     rootProp.dirProperty      = PROPERTY_NULL;
1959     rootProp.startingBlock    = BLOCK_END_OF_CHAIN;
1960     rootProp.size.HighPart    = 0;
1961     rootProp.size.LowPart     = 0;
1962
1963     Storage32Impl_WriteProperty(This, 0, &rootProp);
1964   }
1965
1966   /*
1967    * Find the ID of the root int he property sets.
1968    */
1969   currentPropertyIndex = 0;
1970
1971   do
1972   {
1973     readSucessful = Storage32Impl_ReadProperty(
1974                       This,
1975                       currentPropertyIndex,
1976                       &currentProperty);
1977
1978     if (readSucessful)
1979     {
1980       if ( (currentProperty.sizeOfNameString != 0 ) &&
1981            (currentProperty.propertyType     == PROPTYPE_ROOT) )
1982       {
1983         This->rootPropertySetIndex = currentPropertyIndex;
1984       }
1985     }
1986
1987     currentPropertyIndex++;
1988
1989   } while (readSucessful && (This->rootPropertySetIndex == PROPERTY_NULL) );
1990
1991   if (!readSucessful)
1992   {
1993     /* TODO CLEANUP */
1994     return E_FAIL;
1995   }
1996
1997   /*
1998    * Create the block chain abstraction for the small block root chain.
1999    */
2000   This->smallBlockRootChain = BlockChainStream_Construct(
2001                                 This,
2002                                 NULL,
2003                                 This->rootPropertySetIndex);
2004
2005   return hr;
2006 }
2007
2008 void Storage32Impl_Destroy(
2009   Storage32Impl* This)
2010 {
2011   BlockChainStream_Destroy(This->smallBlockRootChain);
2012   BlockChainStream_Destroy(This->rootBlockChain);
2013   BlockChainStream_Destroy(This->smallBlockDepotChain);
2014
2015   BIGBLOCKFILE_Destructor(This->bigBlockFile);
2016   return;
2017 }
2018
2019 /******************************************************************************
2020  *      Storage32Impl_GetNextFreeBigBlock
2021  *
2022  * Returns the index of the next free big block.
2023  * If the big block depot is filled, this method will enlarge it.
2024  *
2025  */
2026 ULONG Storage32Impl_GetNextFreeBigBlock(
2027   Storage32Impl* This)
2028 {
2029   ULONG depotBlockIndexPos;
2030   void  *depotBuffer;
2031   ULONG depotBlockOffset;
2032   ULONG blocksPerDepot    = This->bigBlockSize / sizeof(ULONG);
2033   ULONG nextBlockIndex    = BLOCK_SPECIAL;
2034   int   depotIndex        = 0;
2035   ULONG blockNoInSequence = 0;
2036
2037   /*
2038    * Scan the entire big block depot until we find a block marked free
2039    */
2040   while (nextBlockIndex != BLOCK_UNUSED)
2041   {
2042     if (depotIndex < COUNT_BBDEPOTINHEADER)
2043     {
2044       depotBlockIndexPos = This->bigBlockDepotStart[depotIndex];
2045
2046       /*
2047        * Grow the primary depot.
2048        */
2049       if (depotBlockIndexPos == BLOCK_UNUSED)
2050       {
2051         depotBlockIndexPos = depotIndex*blocksPerDepot;
2052
2053         /*
2054          * Add a block depot.
2055          */
2056         Storage32Impl_AddBlockDepot(This, depotBlockIndexPos);
2057         This->bigBlockDepotCount++;
2058         This->bigBlockDepotStart[depotIndex] = depotBlockIndexPos;
2059
2060         /*
2061          * Flag it as a block depot.
2062          */
2063         Storage32Impl_SetNextBlockInChain(This,
2064                                           depotBlockIndexPos,
2065                                           BLOCK_SPECIAL);
2066
2067         /* Save new header information.
2068          */
2069         Storage32Impl_SaveFileHeader(This);
2070       }
2071     }
2072     else
2073     {
2074       depotBlockIndexPos = Storage32Impl_GetExtDepotBlock(This, depotIndex);
2075
2076       if (depotBlockIndexPos == BLOCK_UNUSED)
2077       {
2078         /*
2079          * Grow the extended depot.
2080          */
2081         ULONG extIndex       = BLOCK_UNUSED;
2082         ULONG numExtBlocks   = depotIndex - COUNT_BBDEPOTINHEADER;
2083         ULONG extBlockOffset = numExtBlocks % (blocksPerDepot - 1);
2084
2085         if (extBlockOffset == 0)
2086         {
2087           /* We need an extended block.
2088            */
2089           extIndex = Storage32Impl_AddExtBlockDepot(This);
2090           This->extBigBlockDepotCount++;
2091           depotBlockIndexPos = extIndex + 1;
2092         }
2093         else
2094           depotBlockIndexPos = depotIndex * blocksPerDepot;
2095
2096         /*
2097          * Add a block depot and mark it in the extended block.
2098          */
2099         Storage32Impl_AddBlockDepot(This, depotBlockIndexPos);
2100         This->bigBlockDepotCount++;
2101         Storage32Impl_SetExtDepotBlock(This, depotIndex, depotBlockIndexPos);
2102
2103         /* Flag the block depot.
2104          */
2105         Storage32Impl_SetNextBlockInChain(This,
2106                                           depotBlockIndexPos,
2107                                           BLOCK_SPECIAL);
2108
2109         /* If necessary, flag the extended depot block.
2110          */
2111         if (extIndex != BLOCK_UNUSED)
2112           Storage32Impl_SetNextBlockInChain(This, extIndex, BLOCK_EXTBBDEPOT);
2113
2114         /* Save header information.
2115          */
2116         Storage32Impl_SaveFileHeader(This);
2117       }
2118     }
2119
2120     depotBuffer = Storage32Impl_GetROBigBlock(This, depotBlockIndexPos);
2121
2122     if (depotBuffer != 0)
2123     {
2124       depotBlockOffset = 0;
2125
2126       while ( ( (depotBlockOffset/sizeof(ULONG) ) < blocksPerDepot) &&
2127               ( nextBlockIndex != BLOCK_UNUSED))
2128       {
2129         StorageUtl_ReadDWord(depotBuffer, depotBlockOffset, &nextBlockIndex);
2130
2131         if (nextBlockIndex != BLOCK_UNUSED)
2132           blockNoInSequence++;
2133
2134         depotBlockOffset += sizeof(ULONG);
2135       }
2136
2137       Storage32Impl_ReleaseBigBlock(This, depotBuffer);
2138     }
2139
2140     depotIndex++;
2141   }
2142
2143   return blockNoInSequence;
2144 }
2145
2146 /******************************************************************************
2147  *      Storage32Impl_AddBlockDepot
2148  *
2149  * This will create a depot block, essentially it is a block initialized
2150  * to BLOCK_UNUSEDs.
2151  */
2152 void Storage32Impl_AddBlockDepot(Storage32Impl* This, ULONG blockIndex)
2153 {
2154   BYTE* blockBuffer;
2155
2156   blockBuffer = Storage32Impl_GetBigBlock(This, blockIndex);
2157
2158   /*
2159    * Initialize blocks as free
2160    */
2161   memset(blockBuffer, BLOCK_UNUSED, This->bigBlockSize);
2162
2163   Storage32Impl_ReleaseBigBlock(This, blockBuffer);
2164 }
2165
2166 /******************************************************************************
2167  *      Storage32Impl_GetExtDepotBlock
2168  *
2169  * Returns the index of the block that corresponds to the specified depot
2170  * index. This method is only for depot indexes equal or greater than
2171  * COUNT_BBDEPOTINHEADER.
2172  */
2173 ULONG Storage32Impl_GetExtDepotBlock(Storage32Impl* This, ULONG depotIndex)
2174 {
2175   ULONG depotBlocksPerExtBlock = (This->bigBlockSize / sizeof(ULONG)) - 1;
2176   ULONG numExtBlocks           = depotIndex - COUNT_BBDEPOTINHEADER;
2177   ULONG extBlockCount          = numExtBlocks / depotBlocksPerExtBlock;
2178   ULONG extBlockOffset         = numExtBlocks % depotBlocksPerExtBlock;
2179   ULONG blockIndex             = BLOCK_UNUSED;
2180   ULONG extBlockIndex          = This->extBigBlockDepotStart;
2181
2182   assert(depotIndex >= COUNT_BBDEPOTINHEADER);
2183
2184   if (This->extBigBlockDepotStart == BLOCK_END_OF_CHAIN)
2185     return BLOCK_UNUSED;
2186
2187   while (extBlockCount > 0)
2188   {
2189     extBlockIndex = Storage32Impl_GetNextExtendedBlock(This, extBlockIndex);
2190     extBlockCount--;
2191   }
2192
2193   if (extBlockIndex != BLOCK_UNUSED)
2194   {
2195     BYTE* depotBuffer;
2196
2197     depotBuffer = Storage32Impl_GetROBigBlock(This, extBlockIndex);
2198
2199     if (depotBuffer != 0)
2200     {
2201       StorageUtl_ReadDWord(depotBuffer,
2202                            extBlockOffset * sizeof(ULONG),
2203                            &blockIndex);
2204
2205       Storage32Impl_ReleaseBigBlock(This, depotBuffer);
2206     }
2207   }
2208
2209   return blockIndex;
2210 }
2211
2212 /******************************************************************************
2213  *      Storage32Impl_SetExtDepotBlock
2214  *
2215  * Associates the specified block index to the specified depot index.
2216  * This method is only for depot indexes equal or greater than
2217  * COUNT_BBDEPOTINHEADER.
2218  */
2219 void Storage32Impl_SetExtDepotBlock(Storage32Impl* This,
2220                                     ULONG depotIndex,
2221                                     ULONG blockIndex)
2222 {
2223   ULONG depotBlocksPerExtBlock = (This->bigBlockSize / sizeof(ULONG)) - 1;
2224   ULONG numExtBlocks           = depotIndex - COUNT_BBDEPOTINHEADER;
2225   ULONG extBlockCount          = numExtBlocks / depotBlocksPerExtBlock;
2226   ULONG extBlockOffset         = numExtBlocks % depotBlocksPerExtBlock;
2227   ULONG extBlockIndex          = This->extBigBlockDepotStart;
2228
2229   assert(depotIndex >= COUNT_BBDEPOTINHEADER);
2230
2231   while (extBlockCount > 0)
2232   {
2233     extBlockIndex = Storage32Impl_GetNextExtendedBlock(This, extBlockIndex);
2234     extBlockCount--;
2235   }
2236
2237   if (extBlockIndex != BLOCK_UNUSED)
2238   {
2239     BYTE* depotBuffer;
2240
2241     depotBuffer = Storage32Impl_GetBigBlock(This, extBlockIndex);
2242
2243     if (depotBuffer != 0)
2244     {
2245       StorageUtl_WriteDWord(depotBuffer,
2246                             extBlockOffset * sizeof(ULONG),
2247                             blockIndex);
2248
2249       Storage32Impl_ReleaseBigBlock(This, depotBuffer);
2250     }
2251   }
2252 }
2253
2254 /******************************************************************************
2255  *      Storage32Impl_AddExtBlockDepot
2256  *
2257  * Creates an extended depot block.
2258  */
2259 ULONG Storage32Impl_AddExtBlockDepot(Storage32Impl* This)
2260 {
2261   ULONG numExtBlocks           = This->extBigBlockDepotCount;
2262   ULONG nextExtBlock           = This->extBigBlockDepotStart;
2263   BYTE* depotBuffer            = NULL;
2264   ULONG index                  = BLOCK_UNUSED;
2265   ULONG nextBlockOffset        = This->bigBlockSize - sizeof(ULONG);
2266   ULONG blocksPerDepotBlock    = This->bigBlockSize / sizeof(ULONG);
2267   ULONG depotBlocksPerExtBlock = blocksPerDepotBlock - 1;
2268
2269   index = (COUNT_BBDEPOTINHEADER + (numExtBlocks * depotBlocksPerExtBlock)) *
2270           blocksPerDepotBlock;
2271
2272   if ((numExtBlocks == 0) && (nextExtBlock == BLOCK_END_OF_CHAIN))
2273   {
2274     /*
2275      * The first extended block.
2276      */
2277     This->extBigBlockDepotStart = index;
2278   }
2279   else
2280   {
2281     int i;
2282     /*
2283      * Follow the chain to the last one.
2284      */
2285     for (i = 0; i < (numExtBlocks - 1); i++)
2286     {
2287       nextExtBlock = Storage32Impl_GetNextExtendedBlock(This, nextExtBlock);
2288     }
2289
2290     /*
2291      * Add the new extended block to the chain.
2292      */
2293     depotBuffer = Storage32Impl_GetBigBlock(This, nextExtBlock);
2294     StorageUtl_WriteDWord(depotBuffer, nextBlockOffset, index);
2295     Storage32Impl_ReleaseBigBlock(This, depotBuffer);
2296   }
2297
2298   /*
2299    * Initialize this block.
2300    */
2301   depotBuffer = Storage32Impl_GetBigBlock(This, index);
2302   memset(depotBuffer, BLOCK_UNUSED, This->bigBlockSize);
2303   Storage32Impl_ReleaseBigBlock(This, depotBuffer);
2304
2305   return index;
2306 }
2307
2308 /******************************************************************************
2309  *      Storage32Impl_FreeBigBlock
2310  *
2311  * This method will flag the specified block as free in the big block depot.
2312  */
2313 void  Storage32Impl_FreeBigBlock(
2314   Storage32Impl* This,
2315   ULONG          blockIndex)
2316 {
2317   Storage32Impl_SetNextBlockInChain(This, blockIndex, BLOCK_UNUSED);
2318 }
2319
2320 /************************************************************************
2321  * Storage32Impl_GetNextBlockInChain
2322  *
2323  * This method will retrieve the block index of the next big block in
2324  * in the chain.
2325  *
2326  * Params:  This       - Pointer to the Storage object.
2327  *          blockIndex - Index of the block to retrieve the chain
2328  *                       for.
2329  *
2330  * Returns: This method returns the index of the next block in the chain.
2331  *          It will return the constants:
2332  *              BLOCK_SPECIAL - If the block given was not part of a
2333  *                              chain.
2334  *              BLOCK_END_OF_CHAIN - If the block given was the last in
2335  *                                   a chain.
2336  *              BLOCK_UNUSED - If the block given was not past of a chain
2337  *                             and is available.
2338  *              BLOCK_EXTBBDEPOT - This block is part of the extended
2339  *                                 big block depot.
2340  *
2341  * See Windows documentation for more details on IStorage methods.
2342  */
2343 ULONG Storage32Impl_GetNextBlockInChain(
2344   Storage32Impl* This,
2345   ULONG          blockIndex)
2346 {
2347   ULONG offsetInDepot    = blockIndex * sizeof (ULONG);
2348   ULONG depotBlockCount  = offsetInDepot / This->bigBlockSize;
2349   ULONG depotBlockOffset = offsetInDepot % This->bigBlockSize;
2350   ULONG nextBlockIndex   = BLOCK_SPECIAL;
2351   void* depotBuffer;
2352   ULONG depotBlockIndexPos;
2353
2354   assert(depotBlockCount < This->bigBlockDepotCount);
2355
2356   /*
2357    * Cache the currently accessed depot block.
2358    */
2359   if (depotBlockCount != This->indexBlockDepotCached)
2360   {
2361     This->indexBlockDepotCached = depotBlockCount;
2362
2363     if (depotBlockCount < COUNT_BBDEPOTINHEADER)
2364     {
2365       depotBlockIndexPos = This->bigBlockDepotStart[depotBlockCount];
2366     }
2367     else
2368     {
2369       /*
2370        * We have to look in the extended depot.
2371        */
2372       depotBlockIndexPos = Storage32Impl_GetExtDepotBlock(This, depotBlockCount);
2373     }
2374
2375     depotBuffer = Storage32Impl_GetROBigBlock(This, depotBlockIndexPos);
2376
2377     if (depotBuffer!=0)
2378     {
2379       int index;
2380
2381       for (index = 0; index < NUM_BLOCKS_PER_DEPOT_BLOCK; index++)
2382       {
2383         StorageUtl_ReadDWord(depotBuffer, index*sizeof(ULONG), &nextBlockIndex);
2384         This->blockDepotCached[index] = nextBlockIndex;
2385       }
2386
2387       Storage32Impl_ReleaseBigBlock(This, depotBuffer);
2388     }
2389   }
2390
2391   nextBlockIndex = This->blockDepotCached[depotBlockOffset/sizeof(ULONG)];
2392
2393   return nextBlockIndex;
2394 }
2395
2396 /******************************************************************************
2397  *      Storage32Impl_GetNextExtendedBlock
2398  *
2399  * Given an extended block this method will return the next extended block.
2400  *
2401  * NOTES:
2402  * The last ULONG of an extended block is the block index of the next
2403  * extended block. Extended blocks are marked as BLOCK_EXTBBDEPOT in the
2404  * depot.
2405  *
2406  * Return values:
2407  *    - The index of the next extended block
2408  *    - BLOCK_UNUSED: there is no next extended block.
2409  *    - Any other return values denotes failure.
2410  */
2411 ULONG Storage32Impl_GetNextExtendedBlock(Storage32Impl* This, ULONG blockIndex)
2412 {
2413   ULONG nextBlockIndex   = BLOCK_SPECIAL;
2414   ULONG depotBlockOffset = This->bigBlockSize - sizeof(ULONG);
2415   void* depotBuffer;
2416
2417   depotBuffer = Storage32Impl_GetROBigBlock(This, blockIndex);
2418
2419   if (depotBuffer!=0)
2420   {
2421     StorageUtl_ReadDWord(depotBuffer, depotBlockOffset, &nextBlockIndex);
2422
2423     Storage32Impl_ReleaseBigBlock(This, depotBuffer);
2424   }
2425
2426   return nextBlockIndex;
2427 }
2428
2429 /******************************************************************************
2430  *      Storage32Impl_SetNextBlockInChain
2431  *
2432  * This method will write the index of the specified block's next block
2433  * in the big block depot.
2434  *
2435  * For example: to create the chain 3 -> 1 -> 7 -> End of Chain
2436  *              do the following
2437  *
2438  * Storage32Impl_SetNextBlockInChain(This, 3, 1);
2439  * Storage32Impl_SetNextBlockInChain(This, 1, 7);
2440  * Storage32Impl_SetNextBlockInChain(This, 7, BLOCK_END_OF_CHAIN);
2441  *
2442  */
2443 void  Storage32Impl_SetNextBlockInChain(
2444           Storage32Impl* This,
2445           ULONG          blockIndex,
2446           ULONG          nextBlock)
2447 {
2448   ULONG offsetInDepot    = blockIndex * sizeof (ULONG);
2449   ULONG depotBlockCount  = offsetInDepot / This->bigBlockSize;
2450   ULONG depotBlockOffset = offsetInDepot % This->bigBlockSize;
2451   ULONG depotBlockIndexPos;
2452   void* depotBuffer;
2453
2454   assert(depotBlockCount < This->bigBlockDepotCount);
2455
2456   if (depotBlockCount < COUNT_BBDEPOTINHEADER)
2457   {
2458     depotBlockIndexPos = This->bigBlockDepotStart[depotBlockCount];
2459   }
2460   else
2461   {
2462     /*
2463      * We have to look in the extended depot.
2464      */
2465     depotBlockIndexPos = Storage32Impl_GetExtDepotBlock(This, depotBlockCount);
2466   }
2467
2468   depotBuffer = Storage32Impl_GetBigBlock(This, depotBlockIndexPos);
2469
2470   if (depotBuffer!=0)
2471   {
2472     StorageUtl_WriteDWord(depotBuffer, depotBlockOffset, nextBlock);
2473     Storage32Impl_ReleaseBigBlock(This, depotBuffer);
2474   }
2475
2476   /*
2477    * Update the cached block depot, if necessary.
2478    */
2479   if (depotBlockCount == This->indexBlockDepotCached)
2480   {
2481     This->blockDepotCached[depotBlockOffset/sizeof(ULONG)] = nextBlock;
2482   }
2483 }
2484
2485 /******************************************************************************
2486  *      Storage32Impl_LoadFileHeader
2487  *
2488  * This method will read in the file header, i.e. big block index -1.
2489  */
2490 HRESULT Storage32Impl_LoadFileHeader(
2491           Storage32Impl* This)
2492 {
2493   HRESULT hr = STG_E_FILENOTFOUND;
2494   void*   headerBigBlock = NULL;
2495   int     index;
2496
2497   /*
2498    * Get a pointer to the big block of data containing the header.
2499    */
2500   headerBigBlock = Storage32Impl_GetROBigBlock(This, -1);
2501
2502   /*
2503    * Extract the information from the header.
2504    */
2505   if (headerBigBlock!=0)
2506   {
2507     /*
2508      * Check for the "magic number" signature and return an error if it is not
2509      * found.
2510      */
2511     if (memcmp(headerBigBlock, STORAGE_oldmagic, sizeof(STORAGE_oldmagic))==0)
2512     {
2513       Storage32Impl_ReleaseBigBlock(This, headerBigBlock);
2514       return STG_E_OLDFORMAT;
2515     }
2516
2517     if (memcmp(headerBigBlock, STORAGE_magic, sizeof(STORAGE_magic))!=0)
2518     {
2519       Storage32Impl_ReleaseBigBlock(This, headerBigBlock);
2520       return STG_E_INVALIDHEADER;
2521     }
2522
2523     StorageUtl_ReadWord(
2524       headerBigBlock,
2525       OFFSET_BIGBLOCKSIZEBITS,
2526       &This->bigBlockSizeBits);
2527
2528     StorageUtl_ReadWord(
2529       headerBigBlock,
2530       OFFSET_SMALLBLOCKSIZEBITS,
2531       &This->smallBlockSizeBits);
2532
2533     StorageUtl_ReadDWord(
2534       headerBigBlock,
2535       OFFSET_BBDEPOTCOUNT,
2536       &This->bigBlockDepotCount);
2537
2538     StorageUtl_ReadDWord(
2539       headerBigBlock,
2540       OFFSET_ROOTSTARTBLOCK,
2541       &This->rootStartBlock);
2542
2543     StorageUtl_ReadDWord(
2544       headerBigBlock,
2545       OFFSET_SBDEPOTSTART,
2546       &This->smallBlockDepotStart);
2547
2548     StorageUtl_ReadDWord(
2549       headerBigBlock,
2550       OFFSET_EXTBBDEPOTSTART,
2551       &This->extBigBlockDepotStart);
2552
2553     StorageUtl_ReadDWord(
2554       headerBigBlock,
2555       OFFSET_EXTBBDEPOTCOUNT,
2556       &This->extBigBlockDepotCount);
2557
2558     for (index = 0; index < COUNT_BBDEPOTINHEADER; index ++)
2559     {
2560       StorageUtl_ReadDWord(
2561         headerBigBlock,
2562         OFFSET_BBDEPOTSTART + (sizeof(ULONG)*index),
2563         &(This->bigBlockDepotStart[index]));
2564     }
2565
2566     /*
2567      * Make the bitwise arithmetic to get the size of the blocks in bytes.
2568      */
2569     if ((1 << 2) == 4)
2570     {
2571       This->bigBlockSize   = 0x000000001 << (DWORD)This->bigBlockSizeBits;
2572       This->smallBlockSize = 0x000000001 << (DWORD)This->smallBlockSizeBits;
2573     }
2574     else
2575     {
2576       This->bigBlockSize   = 0x000000001 >> (DWORD)This->bigBlockSizeBits;
2577       This->smallBlockSize = 0x000000001 >> (DWORD)This->smallBlockSizeBits;
2578     }
2579
2580     /*
2581      * Right now, the code is making some assumptions about the size of the
2582      * blocks, just make sure they are what we're expecting.
2583      */
2584     assert( (This->bigBlockSize==DEF_BIG_BLOCK_SIZE) &&
2585             (This->smallBlockSize==DEF_SMALL_BLOCK_SIZE));
2586
2587     /*
2588      * Release the block.
2589      */
2590     Storage32Impl_ReleaseBigBlock(This, headerBigBlock);
2591   }
2592
2593   return hr;
2594 }
2595
2596 /******************************************************************************
2597  *      Storage32Impl_SaveFileHeader
2598  *
2599  * This method will save to the file the header, i.e. big block -1.
2600  */
2601 void Storage32Impl_SaveFileHeader(
2602           Storage32Impl* This)
2603 {
2604   BYTE   headerBigBlock[BIG_BLOCK_SIZE];
2605   int    index;
2606   BOOL32 success;
2607
2608   /*
2609    * Get a pointer to the big block of data containing the header.
2610    */
2611   success = Storage32Impl_ReadBigBlock(This, -1, headerBigBlock);
2612
2613   /*
2614    * If the block read failed, the file is probably new.
2615    */
2616   if (!success)
2617   {
2618     /*
2619      * Initialize for all unknown fields.
2620      */
2621     memset(headerBigBlock, 0, BIG_BLOCK_SIZE);
2622
2623     /*
2624      * Initialize the magic number.
2625      */
2626     memcpy(headerBigBlock, STORAGE_magic, sizeof(STORAGE_magic));
2627
2628     /*
2629      * And a bunch of things we don't know what they mean
2630      */
2631     StorageUtl_WriteWord(headerBigBlock,  0x18, 0x3b);
2632     StorageUtl_WriteWord(headerBigBlock,  0x1a, 0x3);
2633     StorageUtl_WriteWord(headerBigBlock,  0x1c, (WORD)-2);
2634     StorageUtl_WriteDWord(headerBigBlock, 0x38, (DWORD)0x1000);
2635     StorageUtl_WriteDWord(headerBigBlock, 0x40, (DWORD)0x0001);
2636   }
2637
2638   /*
2639    * Write the information to the header.
2640    */
2641   if (headerBigBlock!=0)
2642   {
2643     StorageUtl_WriteWord(
2644       headerBigBlock,
2645       OFFSET_BIGBLOCKSIZEBITS,
2646       This->bigBlockSizeBits);
2647
2648     StorageUtl_WriteWord(
2649       headerBigBlock,
2650       OFFSET_SMALLBLOCKSIZEBITS,
2651       This->smallBlockSizeBits);
2652
2653     StorageUtl_WriteDWord(
2654       headerBigBlock,
2655       OFFSET_BBDEPOTCOUNT,
2656       This->bigBlockDepotCount);
2657
2658     StorageUtl_WriteDWord(
2659       headerBigBlock,
2660       OFFSET_ROOTSTARTBLOCK,
2661       This->rootStartBlock);
2662
2663     StorageUtl_WriteDWord(
2664       headerBigBlock,
2665       OFFSET_SBDEPOTSTART,
2666       This->smallBlockDepotStart);
2667
2668     StorageUtl_WriteDWord(
2669       headerBigBlock,
2670       OFFSET_EXTBBDEPOTSTART,
2671       This->extBigBlockDepotStart);
2672
2673     StorageUtl_WriteDWord(
2674       headerBigBlock,
2675       OFFSET_EXTBBDEPOTCOUNT,
2676       This->extBigBlockDepotCount);
2677
2678     for (index = 0; index < COUNT_BBDEPOTINHEADER; index ++)
2679     {
2680       StorageUtl_WriteDWord(
2681         headerBigBlock,
2682         OFFSET_BBDEPOTSTART + (sizeof(ULONG)*index),
2683         (This->bigBlockDepotStart[index]));
2684     }
2685   }
2686
2687   /*
2688    * Write the big block back to the file.
2689    */
2690   Storage32Impl_WriteBigBlock(This, -1, headerBigBlock);
2691 }
2692
2693 /******************************************************************************
2694  *      Storage32Impl_ReadProperty
2695  *
2696  * This method will read the specified property from the property chain.
2697  */
2698 BOOL32 Storage32Impl_ReadProperty(
2699   Storage32Impl* This,
2700   ULONG          index,
2701   StgProperty*   buffer)
2702 {
2703   BYTE           currentProperty[PROPSET_BLOCK_SIZE];
2704   ULARGE_INTEGER offsetInPropSet;
2705   BOOL32         readSucessful;
2706   ULONG          bytesRead;
2707
2708   offsetInPropSet.HighPart = 0;
2709   offsetInPropSet.LowPart  = index * PROPSET_BLOCK_SIZE;
2710
2711   readSucessful = BlockChainStream_ReadAt(
2712                     This->rootBlockChain,
2713                     offsetInPropSet,
2714                     PROPSET_BLOCK_SIZE,
2715                     currentProperty,
2716                     &bytesRead);
2717
2718   if (readSucessful)
2719   {
2720     memset(buffer->name, 0, sizeof(buffer->name));
2721     memcpy(
2722       buffer->name,
2723       currentProperty+OFFSET_PS_NAME,
2724       PROPERTY_NAME_BUFFER_LEN );
2725
2726     memcpy(&buffer->propertyType, currentProperty + OFFSET_PS_PROPERTYTYPE, 1);
2727
2728     StorageUtl_ReadWord(
2729       currentProperty,
2730       OFFSET_PS_NAMELENGTH,
2731       &buffer->sizeOfNameString);
2732
2733     StorageUtl_ReadDWord(
2734       currentProperty,
2735       OFFSET_PS_PREVIOUSPROP,
2736       &buffer->previousProperty);
2737
2738     StorageUtl_ReadDWord(
2739       currentProperty,
2740       OFFSET_PS_NEXTPROP,
2741       &buffer->nextProperty);
2742
2743     StorageUtl_ReadDWord(
2744       currentProperty,
2745       OFFSET_PS_DIRPROP,
2746       &buffer->dirProperty);
2747
2748     StorageUtl_ReadGUID(
2749       currentProperty,
2750       OFFSET_PS_GUID,
2751       &buffer->propertyUniqueID);
2752
2753     StorageUtl_ReadDWord(
2754       currentProperty,
2755       OFFSET_PS_TSS1,
2756       &buffer->timeStampS1);
2757
2758     StorageUtl_ReadDWord(
2759       currentProperty,
2760       OFFSET_PS_TSD1,
2761       &buffer->timeStampD1);
2762
2763     StorageUtl_ReadDWord(
2764       currentProperty,
2765       OFFSET_PS_TSS2,
2766       &buffer->timeStampS2);
2767
2768     StorageUtl_ReadDWord(
2769       currentProperty,
2770       OFFSET_PS_TSD2,
2771       &buffer->timeStampD2);
2772
2773     StorageUtl_ReadDWord(
2774       currentProperty,
2775       OFFSET_PS_STARTBLOCK,
2776       &buffer->startingBlock);
2777
2778     StorageUtl_ReadDWord(
2779       currentProperty,
2780       OFFSET_PS_SIZE,
2781       &buffer->size.LowPart);
2782
2783     buffer->size.HighPart = 0;
2784   }
2785
2786   return readSucessful;
2787 }
2788
2789 /*********************************************************************
2790  * Write the specified property into the property chain
2791  */
2792 BOOL32 Storage32Impl_WriteProperty(
2793   Storage32Impl* This,
2794   ULONG          index,
2795   StgProperty*   buffer)
2796 {
2797   BYTE           currentProperty[PROPSET_BLOCK_SIZE];
2798   ULARGE_INTEGER offsetInPropSet;
2799   BOOL32         writeSucessful;
2800   ULONG          bytesWritten;
2801
2802   offsetInPropSet.HighPart = 0;
2803   offsetInPropSet.LowPart  = index * PROPSET_BLOCK_SIZE;
2804
2805   memset(currentProperty, 0, PROPSET_BLOCK_SIZE);
2806
2807   memcpy(
2808     currentProperty + OFFSET_PS_NAME,
2809     buffer->name,
2810     PROPERTY_NAME_BUFFER_LEN );
2811
2812   memcpy(currentProperty + OFFSET_PS_PROPERTYTYPE, &buffer->propertyType, 1);
2813
2814   /*
2815    * Reassign the size in case of mistake....
2816    */
2817   buffer->sizeOfNameString = (lstrlen32W(buffer->name)+1) * sizeof(WCHAR);
2818
2819   StorageUtl_WriteWord(
2820     currentProperty,
2821       OFFSET_PS_NAMELENGTH,
2822       buffer->sizeOfNameString);
2823
2824   StorageUtl_WriteDWord(
2825     currentProperty,
2826       OFFSET_PS_PREVIOUSPROP,
2827       buffer->previousProperty);
2828
2829   StorageUtl_WriteDWord(
2830     currentProperty,
2831       OFFSET_PS_NEXTPROP,
2832       buffer->nextProperty);
2833
2834   StorageUtl_WriteDWord(
2835     currentProperty,
2836       OFFSET_PS_DIRPROP,
2837       buffer->dirProperty);
2838
2839   StorageUtl_WriteGUID(
2840     currentProperty,
2841       OFFSET_PS_GUID,
2842       &buffer->propertyUniqueID);
2843
2844   StorageUtl_WriteDWord(
2845     currentProperty,
2846       OFFSET_PS_TSS1,
2847       buffer->timeStampS1);
2848
2849   StorageUtl_WriteDWord(
2850     currentProperty,
2851       OFFSET_PS_TSD1,
2852       buffer->timeStampD1);
2853
2854   StorageUtl_WriteDWord(
2855     currentProperty,
2856       OFFSET_PS_TSS2,
2857       buffer->timeStampS2);
2858
2859   StorageUtl_WriteDWord(
2860     currentProperty,
2861       OFFSET_PS_TSD2,
2862       buffer->timeStampD2);
2863
2864   StorageUtl_WriteDWord(
2865     currentProperty,
2866       OFFSET_PS_STARTBLOCK,
2867       buffer->startingBlock);
2868
2869   StorageUtl_WriteDWord(
2870     currentProperty,
2871       OFFSET_PS_SIZE,
2872       buffer->size.LowPart);
2873
2874   writeSucessful = BlockChainStream_WriteAt(This->rootBlockChain,
2875                                             offsetInPropSet,
2876                                             PROPSET_BLOCK_SIZE,
2877                                             currentProperty,
2878                                             &bytesWritten);
2879   return writeSucessful;
2880 }
2881
2882 BOOL32 Storage32Impl_ReadBigBlock(
2883   Storage32Impl* This,
2884   ULONG          blockIndex,
2885   void*          buffer)
2886 {
2887   void* bigBlockBuffer;
2888
2889   bigBlockBuffer = Storage32Impl_GetROBigBlock(This, blockIndex);
2890
2891   if (bigBlockBuffer!=0)
2892   {
2893     memcpy(buffer, bigBlockBuffer, This->bigBlockSize);
2894
2895     Storage32Impl_ReleaseBigBlock(This, bigBlockBuffer);
2896
2897     return TRUE;
2898   }
2899
2900   return FALSE;
2901 }
2902
2903 BOOL32 Storage32Impl_WriteBigBlock(
2904   Storage32Impl* This,
2905   ULONG          blockIndex,
2906   void*          buffer)
2907 {
2908   void* bigBlockBuffer;
2909
2910   bigBlockBuffer = Storage32Impl_GetBigBlock(This, blockIndex);
2911
2912   if (bigBlockBuffer!=0)
2913   {
2914     memcpy(bigBlockBuffer, buffer, This->bigBlockSize);
2915
2916     Storage32Impl_ReleaseBigBlock(This, bigBlockBuffer);
2917
2918     return TRUE;
2919   }
2920
2921   return FALSE;
2922 }
2923
2924 void* Storage32Impl_GetROBigBlock(
2925   Storage32Impl* This,
2926   ULONG          blockIndex)
2927 {
2928   return BIGBLOCKFILE_GetROBigBlock(This->bigBlockFile, blockIndex);
2929 }
2930
2931 void* Storage32Impl_GetBigBlock(
2932   Storage32Impl* This,
2933   ULONG          blockIndex)
2934 {
2935   return BIGBLOCKFILE_GetBigBlock(This->bigBlockFile, blockIndex);
2936 }
2937
2938 void Storage32Impl_ReleaseBigBlock(
2939   Storage32Impl* This,
2940   void*          pBigBlock)
2941 {
2942   BIGBLOCKFILE_ReleaseBigBlock(This->bigBlockFile, pBigBlock);
2943 }
2944
2945 /******************************************************************************
2946  *              Storage32Impl_SmallBlocksToBigBlocks
2947  *
2948  * This method will convert a small block chain to a big block chain.
2949  * The small block chain will be destroyed.
2950  */
2951 BlockChainStream* Storage32Impl_SmallBlocksToBigBlocks(
2952                       Storage32Impl* This,
2953                       SmallBlockChainStream** ppsbChain)
2954 {
2955   ULONG bbHeadOfChain = BLOCK_END_OF_CHAIN;
2956   ULARGE_INTEGER size, offset;
2957   ULONG cbRead, cbWritten, cbTotalRead, cbTotalWritten;
2958   ULONG propertyIndex;
2959   BOOL32 successRead, successWrite;
2960   StgProperty chainProperty;
2961   BYTE buffer[DEF_SMALL_BLOCK_SIZE];
2962   BlockChainStream *bbTempChain = NULL;
2963   BlockChainStream *bigBlockChain = NULL;
2964
2965   /*
2966    * Create a temporary big block chain that doesn't have
2967    * an associated property. This temporary chain will be
2968    * used to copy data from small blocks to big blocks.
2969    */
2970   bbTempChain = BlockChainStream_Construct(This,
2971                                            &bbHeadOfChain,
2972                                            PROPERTY_NULL);
2973
2974   /*
2975    * Grow the big block chain.
2976    */
2977   size = SmallBlockChainStream_GetSize(*ppsbChain);
2978   BlockChainStream_SetSize(bbTempChain, size);
2979
2980   /*
2981    * Copy the contents of the small block chain to the big block chain
2982    * by small block size increments.
2983    */
2984   offset.LowPart = 0;
2985   offset.HighPart = 0;
2986   cbTotalRead = 0;
2987   cbTotalWritten = 0;
2988
2989   do
2990   {
2991     successRead = SmallBlockChainStream_ReadAt(*ppsbChain,
2992                                                offset,
2993                                                sizeof(buffer),
2994                                                buffer,
2995                                                &cbRead);
2996     cbTotalRead += cbRead;
2997
2998     successWrite = BlockChainStream_WriteAt(bbTempChain,
2999                                             offset,
3000                                             cbRead,
3001                                             buffer,
3002                                             &cbWritten);
3003     cbTotalWritten += cbWritten;
3004
3005     offset.LowPart += This->smallBlockSize;
3006
3007   } while (successRead && successWrite);
3008
3009   assert(cbTotalRead == cbTotalWritten);
3010
3011   /*
3012    * Destroy the small block chain.
3013    */
3014   propertyIndex = (*ppsbChain)->ownerPropertyIndex;
3015   size.HighPart = 0;
3016   size.LowPart  = 0;
3017   SmallBlockChainStream_SetSize(*ppsbChain, size);
3018   SmallBlockChainStream_Destroy(*ppsbChain);
3019   *ppsbChain = 0;
3020
3021   /*
3022    * Change the property information. This chain is now a big block chain
3023    * and it doesn't reside in the small blocks chain anymore.
3024    */
3025   Storage32Impl_ReadProperty(This, propertyIndex, &chainProperty);
3026
3027   chainProperty.startingBlock = bbHeadOfChain;
3028
3029   Storage32Impl_WriteProperty(This, propertyIndex, &chainProperty);
3030
3031   /*
3032    * Destroy the temporary propertyless big block chain.
3033    * Create a new big block chain associated with this property.
3034    */
3035   BlockChainStream_Destroy(bbTempChain);
3036   bigBlockChain = BlockChainStream_Construct(This,
3037                                              NULL,
3038                                              propertyIndex);
3039
3040   return bigBlockChain;
3041 }
3042
3043 /******************************************************************************
3044 ** Storage32InternalImpl implementation
3045 */
3046
3047 Storage32InternalImpl* Storage32InternalImpl_Construct(
3048   Storage32Impl* ancestorStorage,
3049   ULONG          rootPropertyIndex)
3050 {
3051   Storage32InternalImpl* newStorage;
3052
3053   /*
3054    * Allocate space for the new storage object
3055    */
3056   newStorage = HeapAlloc(GetProcessHeap(), 0, sizeof(Storage32InternalImpl));
3057
3058   if (newStorage!=0)
3059   {
3060     memset(newStorage, 0, sizeof(Storage32InternalImpl));
3061
3062     /*
3063      * Initialize the virtual function table.
3064      */
3065     newStorage->lpvtbl       = &Storage32InternalImpl_Vtbl;
3066     newStorage->v_destructor = &Storage32InternalImpl_Destroy;
3067
3068     /*
3069      * Keep the ancestor storage pointer and nail a reference to it.
3070      */
3071     newStorage->ancestorStorage = ancestorStorage;
3072     Storage32BaseImpl_AddRef((IStorage32*)(newStorage->ancestorStorage));
3073
3074     /*
3075      * Keep the index of the root property set for this storage,
3076      */
3077     newStorage->rootPropertySetIndex = rootPropertyIndex;
3078
3079     return newStorage;
3080   }
3081
3082   return 0;
3083 }
3084
3085 void Storage32InternalImpl_Destroy(
3086   Storage32InternalImpl* This)
3087 {
3088   HeapFree(GetProcessHeap(), 0, This);
3089 }
3090
3091 /******************************************************************************
3092 **
3093 ** Storage32InternalImpl_Commit
3094 **
3095 ** The non-root storages cannot be opened in transacted mode thus this function
3096 ** does nothing.
3097 */
3098 HRESULT WINAPI Storage32InternalImpl_Commit(
3099   IStorage32*            iface,
3100   DWORD                  grfCommitFlags)  /* [in] */
3101 {
3102   return S_OK;
3103 }
3104
3105 /******************************************************************************
3106 **
3107 ** Storage32InternalImpl_Revert
3108 **
3109 ** The non-root storages cannot be opened in transacted mode thus this function
3110 ** does nothing.
3111 */
3112 HRESULT WINAPI Storage32InternalImpl_Revert(
3113   IStorage32*            iface)
3114 {
3115   return S_OK;
3116 }
3117
3118 /******************************************************************************
3119 ** IEnumSTATSTGImpl implementation
3120 */
3121
3122 IEnumSTATSTGImpl* IEnumSTATSTGImpl_Construct(
3123   Storage32Impl* parentStorage,
3124   ULONG          firstPropertyNode)
3125 {
3126   IEnumSTATSTGImpl* newEnumeration;
3127
3128   newEnumeration = HeapAlloc(GetProcessHeap(), 0, sizeof(IEnumSTATSTGImpl));
3129
3130   if (newEnumeration!=0)
3131   {
3132     /*
3133      * Set-up the virtual function table and reference count.
3134      */
3135     newEnumeration->lpvtbl = &IEnumSTATSTGImpl_Vtbl;
3136     newEnumeration->ref    = 0;
3137
3138     /*
3139      * We want to nail-down the reference to the storage in case the
3140      * enumeration out-lives the storage in the client application.
3141      */
3142     newEnumeration->parentStorage = parentStorage;
3143     IStorage32_AddRef((IStorage32*)newEnumeration->parentStorage);
3144
3145     newEnumeration->firstPropertyNode   = firstPropertyNode;
3146
3147     /*
3148      * Initialize the search stack
3149      */
3150     newEnumeration->stackSize    = 0;
3151     newEnumeration->stackMaxSize = ENUMSTATSGT_SIZE_INCREMENT;
3152     newEnumeration->stackToVisit =
3153       HeapAlloc(GetProcessHeap(), 0, sizeof(ULONG)*ENUMSTATSGT_SIZE_INCREMENT);
3154
3155     /*
3156      * Make sure the current node of the iterator is the first one.
3157      */
3158     IEnumSTATSTGImpl_Reset((IEnumSTATSTG*)newEnumeration);
3159   }
3160
3161   return newEnumeration;
3162 }
3163
3164 void IEnumSTATSTGImpl_Destroy(IEnumSTATSTGImpl* This)
3165 {
3166   IStorage32_Release((IStorage32*)This->parentStorage);
3167   HeapFree(GetProcessHeap(), 0, This->stackToVisit);
3168   HeapFree(GetProcessHeap(), 0, This);
3169 }
3170
3171 HRESULT WINAPI IEnumSTATSTGImpl_QueryInterface(
3172   IEnumSTATSTG*     iface,
3173   REFIID            riid,
3174   void**            ppvObject)
3175 {
3176   IEnumSTATSTGImpl* const This=(IEnumSTATSTGImpl*)iface;
3177
3178   /*
3179    * Perform a sanity check on the parameters.
3180    */
3181   if (ppvObject==0)
3182     return E_INVALIDARG;
3183
3184   /*
3185    * Initialize the return parameter.
3186    */
3187   *ppvObject = 0;
3188
3189   /*
3190    * Compare the riid with the interface IDs implemented by this object.
3191    */
3192   if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0)
3193   {
3194     *ppvObject = (IEnumSTATSTG*)This;
3195   }
3196   else if (memcmp(&IID_IStorage, riid, sizeof(IID_IEnumSTATSTG)) == 0)
3197   {
3198     *ppvObject = (IEnumSTATSTG*)This;
3199   }
3200
3201   /*
3202    * Check that we obtained an interface.
3203    */
3204   if ((*ppvObject)==0)
3205     return E_NOINTERFACE;
3206
3207   /*
3208    * Query Interface always increases the reference count by one when it is
3209    * successful
3210    */
3211   IEnumSTATSTGImpl_AddRef((IEnumSTATSTG*)This);
3212
3213   return S_OK;
3214 }
3215
3216 ULONG   WINAPI IEnumSTATSTGImpl_AddRef(
3217   IEnumSTATSTG* iface)
3218 {
3219   IEnumSTATSTGImpl* const This=(IEnumSTATSTGImpl*)iface;
3220
3221   This->ref++;
3222   return This->ref;
3223 }
3224
3225 ULONG   WINAPI IEnumSTATSTGImpl_Release(
3226   IEnumSTATSTG* iface)
3227 {
3228   IEnumSTATSTGImpl* const This=(IEnumSTATSTGImpl*)iface;
3229
3230   ULONG newRef;
3231
3232   This->ref--;
3233   newRef = This->ref;
3234
3235   /*
3236    * If the reference count goes down to 0, perform suicide.
3237    */
3238   if (newRef==0)
3239   {
3240     IEnumSTATSTGImpl_Destroy(This);
3241   }
3242
3243   return newRef;;
3244 }
3245
3246 HRESULT WINAPI IEnumSTATSTGImpl_Next(
3247   IEnumSTATSTG* iface,
3248   ULONG             celt,
3249   STATSTG*          rgelt,
3250   ULONG*            pceltFetched)
3251 {
3252   IEnumSTATSTGImpl* const This=(IEnumSTATSTGImpl*)iface;
3253
3254   StgProperty currentProperty;
3255   STATSTG*    currentReturnStruct = rgelt;
3256   ULONG       objectFetched       = 0;
3257   ULONG      currentSearchNode;
3258
3259   /*
3260    * Perform a sanity check on the parameters.
3261    */
3262   if ( (rgelt==0) || ( (celt!=1) && (pceltFetched==0) ) )
3263     return E_INVALIDARG;
3264
3265   /*
3266    * To avoid the special case, get another pointer to a ULONG value if
3267    * the caller didn't supply one.
3268    */
3269   if (pceltFetched==0)
3270     pceltFetched = &objectFetched;
3271
3272   /*
3273    * Start the iteration, we will iterate until we hit the end of the
3274    * linked list or until we hit the number of items to iterate through
3275    */
3276   *pceltFetched = 0;
3277
3278   /*
3279    * Start with the node at the top of the stack.
3280    */
3281   currentSearchNode = IEnumSTATSTGImpl_PopSearchNode(This, FALSE);
3282
3283   while ( ( *pceltFetched < celt) &&
3284           ( currentSearchNode!=PROPERTY_NULL) )
3285   {
3286     /*
3287      * Remove the top node from the stack
3288      */
3289     IEnumSTATSTGImpl_PopSearchNode(This, TRUE);
3290
3291     /*
3292      * Read the property from the storage.
3293      */
3294     Storage32Impl_ReadProperty(This->parentStorage,
3295       currentSearchNode,
3296       &currentProperty);
3297
3298     /*
3299      * Copy the information to the return buffer.
3300      */
3301     StorageUtl_CopyPropertyToSTATSTG(currentReturnStruct,
3302       &currentProperty,
3303       STATFLAG_DEFAULT);
3304
3305     /*
3306      * Step to the next item in the iteration
3307      */
3308     (*pceltFetched)++;
3309     currentReturnStruct++;
3310
3311     /*
3312      * Push the next search node in the search stack.
3313      */
3314     IEnumSTATSTGImpl_PushSearchNode(This, currentProperty.nextProperty);
3315
3316     /*
3317      * continue the iteration.
3318      */
3319     currentSearchNode = IEnumSTATSTGImpl_PopSearchNode(This, FALSE);
3320   }
3321
3322   if (*pceltFetched == celt)
3323     return S_OK;
3324
3325   return S_FALSE;
3326 }
3327
3328
3329 HRESULT WINAPI IEnumSTATSTGImpl_Skip(
3330   IEnumSTATSTG* iface,
3331   ULONG             celt)
3332 {
3333   IEnumSTATSTGImpl* const This=(IEnumSTATSTGImpl*)iface;
3334
3335   StgProperty currentProperty;
3336   ULONG       objectFetched       = 0;
3337   ULONG       currentSearchNode;
3338
3339   /*
3340    * Start with the node at the top of the stack.
3341    */
3342   currentSearchNode = IEnumSTATSTGImpl_PopSearchNode(This, FALSE);
3343
3344   while ( (objectFetched < celt) &&
3345           (currentSearchNode!=PROPERTY_NULL) )
3346   {
3347     /*
3348      * Remove the top node from the stack
3349      */
3350     IEnumSTATSTGImpl_PopSearchNode(This, TRUE);
3351
3352     /*
3353      * Read the property from the storage.
3354      */
3355     Storage32Impl_ReadProperty(This->parentStorage,
3356       currentSearchNode,
3357       &currentProperty);
3358
3359     /*
3360      * Step to the next item in the iteration
3361      */
3362     objectFetched++;
3363
3364     /*
3365      * Push the next search node in the search stack.
3366      */
3367     IEnumSTATSTGImpl_PushSearchNode(This, currentProperty.nextProperty);
3368
3369     /*
3370      * continue the iteration.
3371      */
3372     currentSearchNode = IEnumSTATSTGImpl_PopSearchNode(This, FALSE);
3373   }
3374
3375   if (objectFetched == celt)
3376     return S_OK;
3377
3378   return S_FALSE;
3379 }
3380
3381 HRESULT WINAPI IEnumSTATSTGImpl_Reset(
3382   IEnumSTATSTG* iface)
3383 {
3384   IEnumSTATSTGImpl* const This=(IEnumSTATSTGImpl*)iface;
3385
3386   StgProperty rootProperty;
3387   BOOL32      readSucessful;
3388
3389   /*
3390    * Re-initialize the search stack to an empty stack
3391    */
3392   This->stackSize = 0;
3393
3394   /*
3395    * Read the root property from the storage.
3396    */
3397   readSucessful = Storage32Impl_ReadProperty(
3398                     This->parentStorage,
3399                     This->firstPropertyNode,
3400                     &rootProperty);
3401
3402   if (readSucessful)
3403   {
3404     assert(rootProperty.sizeOfNameString!=0);
3405
3406     /*
3407      * Push the search node in the search stack.
3408      */
3409     IEnumSTATSTGImpl_PushSearchNode(This, rootProperty.dirProperty);
3410   }
3411
3412   return S_OK;
3413 }
3414
3415 HRESULT WINAPI IEnumSTATSTGImpl_Clone(
3416   IEnumSTATSTG* iface,
3417   IEnumSTATSTG**    ppenum)
3418 {
3419   IEnumSTATSTGImpl* const This=(IEnumSTATSTGImpl*)iface;
3420
3421   IEnumSTATSTGImpl* newClone;
3422
3423   /*
3424    * Perform a sanity check on the parameters.
3425    */
3426   if (ppenum==0)
3427     return E_INVALIDARG;
3428
3429   newClone = IEnumSTATSTGImpl_Construct(This->parentStorage,
3430                This->firstPropertyNode);
3431
3432
3433   /*
3434    * The new clone enumeration must point to the same current node as
3435    * the ole one.
3436    */
3437   newClone->stackSize    = This->stackSize    ;
3438   newClone->stackMaxSize = This->stackMaxSize ;
3439   newClone->stackToVisit =
3440     HeapAlloc(GetProcessHeap(), 0, sizeof(ULONG) * newClone->stackMaxSize);
3441
3442   memcpy(
3443     newClone->stackToVisit,
3444     This->stackToVisit,
3445     sizeof(ULONG) * newClone->stackSize);
3446
3447   *ppenum = (IEnumSTATSTG*)newClone;
3448
3449   /*
3450    * Don't forget to nail down a reference to the clone before
3451    * returning it.
3452    */
3453   IEnumSTATSTGImpl_AddRef(*ppenum);
3454
3455   return S_OK;
3456 }
3457
3458 INT32 IEnumSTATSTGImpl_FindParentProperty(
3459   IEnumSTATSTGImpl *This,
3460   ULONG             childProperty,
3461   StgProperty      *currentProperty,
3462   ULONG            *thisNodeId)
3463 {
3464   ULONG currentSearchNode;
3465   ULONG foundNode;
3466
3467   /*
3468    * To avoid the special case, get another pointer to a ULONG value if
3469    * the caller didn't supply one.
3470    */
3471   if (thisNodeId==0)
3472     thisNodeId = &foundNode;
3473
3474   /*
3475    * Start with the node at the top of the stack.
3476    */
3477   currentSearchNode = IEnumSTATSTGImpl_PopSearchNode(This, FALSE);
3478
3479
3480   while (currentSearchNode!=PROPERTY_NULL)
3481   {
3482     /*
3483      * Store the current node in the returned parameters
3484      */
3485     *thisNodeId = currentSearchNode;
3486
3487     /*
3488      * Remove the top node from the stack
3489      */
3490     IEnumSTATSTGImpl_PopSearchNode(This, TRUE);
3491
3492     /*
3493      * Read the property from the storage.
3494      */
3495     Storage32Impl_ReadProperty(
3496       This->parentStorage,
3497       currentSearchNode,
3498       currentProperty);
3499
3500     if (currentProperty->previousProperty == childProperty)
3501       return PROPERTY_RELATION_PREVIOUS;
3502
3503     else if (currentProperty->nextProperty == childProperty)
3504       return PROPERTY_RELATION_NEXT;
3505
3506     else if (currentProperty->dirProperty == childProperty)
3507       return PROPERTY_RELATION_DIR;
3508
3509     /*
3510      * Push the next search node in the search stack.
3511      */
3512     IEnumSTATSTGImpl_PushSearchNode(This, currentProperty->nextProperty);
3513
3514     /*
3515      * continue the iteration.
3516      */
3517     currentSearchNode = IEnumSTATSTGImpl_PopSearchNode(This, FALSE);
3518   }
3519
3520   return PROPERTY_NULL;
3521 }
3522
3523 ULONG IEnumSTATSTGImpl_FindProperty(
3524   IEnumSTATSTGImpl* This,
3525   const OLECHAR32*  lpszPropName,
3526   StgProperty*      currentProperty)
3527 {
3528   ULONG currentSearchNode;
3529
3530   /*
3531    * Start with the node at the top of the stack.
3532    */
3533   currentSearchNode = IEnumSTATSTGImpl_PopSearchNode(This, FALSE);
3534
3535   while (currentSearchNode!=PROPERTY_NULL)
3536   {
3537     /*
3538      * Remove the top node from the stack
3539      */
3540     IEnumSTATSTGImpl_PopSearchNode(This, TRUE);
3541
3542     /*
3543      * Read the property from the storage.
3544      */
3545     Storage32Impl_ReadProperty(This->parentStorage,
3546       currentSearchNode,
3547       currentProperty);
3548
3549     if ( propertyNameCmp(
3550           (OLECHAR32*)currentProperty->name,
3551           (OLECHAR32*)lpszPropName) == 0)
3552       return currentSearchNode;
3553
3554     /*
3555      * Push the next search node in the search stack.
3556      */
3557     IEnumSTATSTGImpl_PushSearchNode(This, currentProperty->nextProperty);
3558
3559     /*
3560      * continue the iteration.
3561      */
3562     currentSearchNode = IEnumSTATSTGImpl_PopSearchNode(This, FALSE);
3563   }
3564
3565   return PROPERTY_NULL;
3566 }
3567
3568 void IEnumSTATSTGImpl_PushSearchNode(
3569   IEnumSTATSTGImpl* This,
3570   ULONG             nodeToPush)
3571 {
3572   StgProperty rootProperty;
3573   BOOL32      readSucessful;
3574
3575   /*
3576    * First, make sure we're not trying to push an unexisting node.
3577    */
3578   if (nodeToPush==PROPERTY_NULL)
3579     return;
3580
3581   /*
3582    * First push the node to the stack
3583    */
3584   if (This->stackSize == This->stackMaxSize)
3585   {
3586     This->stackMaxSize += ENUMSTATSGT_SIZE_INCREMENT;
3587
3588     This->stackToVisit = HeapReAlloc(
3589                            GetProcessHeap(),
3590                            0,
3591                            This->stackToVisit,
3592                            sizeof(ULONG) * This->stackMaxSize);
3593   }
3594
3595   This->stackToVisit[This->stackSize] = nodeToPush;
3596   This->stackSize++;
3597
3598   /*
3599    * Read the root property from the storage.
3600    */
3601   readSucessful = Storage32Impl_ReadProperty(
3602                     This->parentStorage,
3603                     nodeToPush,
3604                     &rootProperty);
3605
3606   if (readSucessful)
3607   {
3608     assert(rootProperty.sizeOfNameString!=0);
3609
3610     /*
3611      * Push the previous search node in the search stack.
3612      */
3613     IEnumSTATSTGImpl_PushSearchNode(This, rootProperty.previousProperty);
3614   }
3615 }
3616
3617 ULONG IEnumSTATSTGImpl_PopSearchNode(
3618   IEnumSTATSTGImpl* This,
3619   BOOL32            remove)
3620 {
3621   ULONG topNode;
3622
3623   if (This->stackSize == 0)
3624     return PROPERTY_NULL;
3625
3626   topNode = This->stackToVisit[This->stackSize-1];
3627
3628   if (remove)
3629     This->stackSize--;
3630
3631   return topNode;
3632 }
3633
3634 /******************************************************************************
3635 ** StorageUtl implementation
3636 */
3637
3638 void StorageUtl_ReadWord(void* buffer, ULONG offset, WORD* value)
3639 {
3640   memcpy(value, (BYTE*)buffer+offset, sizeof(WORD));
3641 }
3642
3643 void StorageUtl_WriteWord(void* buffer, ULONG offset, WORD value)
3644 {
3645   memcpy((BYTE*)buffer+offset, &value, sizeof(WORD));
3646 }
3647
3648 void StorageUtl_ReadDWord(void* buffer, ULONG offset, DWORD* value)
3649 {
3650   memcpy(value, (BYTE*)buffer+offset, sizeof(DWORD));
3651 }
3652
3653 void StorageUtl_WriteDWord(void* buffer, ULONG offset, DWORD value)
3654 {
3655   memcpy((BYTE*)buffer+offset, &value, sizeof(DWORD));
3656 }
3657
3658 void StorageUtl_ReadGUID(void* buffer, ULONG offset, GUID* value)
3659 {
3660   StorageUtl_ReadDWord(buffer, offset,   &(value->Data1));
3661   StorageUtl_ReadWord(buffer,  offset+4, &(value->Data2));
3662   StorageUtl_ReadWord(buffer,  offset+6, &(value->Data3));
3663
3664   memcpy(value->Data4, (BYTE*)buffer+offset+8, sizeof(value->Data4));
3665 }
3666
3667 void StorageUtl_WriteGUID(void* buffer, ULONG offset, GUID* value)
3668 {
3669   StorageUtl_WriteDWord(buffer, offset,   value->Data1);
3670   StorageUtl_WriteWord(buffer,  offset+4, value->Data2);
3671   StorageUtl_WriteWord(buffer,  offset+6, value->Data3);
3672
3673   memcpy((BYTE*)buffer+offset+8, value->Data4, sizeof(value->Data4));
3674 }
3675
3676 void StorageUtl_CopyPropertyToSTATSTG(
3677   STATSTG*     destination,
3678   StgProperty* source,
3679   int          statFlags)
3680 {
3681   /*
3682    * The copy of the string occurs only when the flag is not set
3683    */
3684   if ((statFlags & STATFLAG_NONAME) != 0)
3685   {
3686     destination->pwcsName = 0;
3687   }
3688   else
3689   {
3690     destination->pwcsName =
3691       CoTaskMemAlloc((lstrlen32W(source->name)+1)*sizeof(WCHAR));
3692
3693     lstrcpy32W((LPWSTR)destination->pwcsName, source->name);
3694   }
3695
3696   switch (source->propertyType)
3697   {
3698     case PROPTYPE_STORAGE:
3699     case PROPTYPE_ROOT:
3700       destination->type = STGTY_STORAGE;
3701       break;
3702     case PROPTYPE_STREAM:
3703       destination->type = STGTY_STREAM;
3704       break;
3705     default:
3706       destination->type = STGTY_STREAM;
3707       break;
3708   }
3709
3710   destination->cbSize            = source->size;
3711 /*
3712   currentReturnStruct->mtime     = {0}; TODO
3713   currentReturnStruct->ctime     = {0};
3714   currentReturnStruct->atime     = {0};
3715 */
3716   destination->grfMode           = 0;
3717   destination->grfLocksSupported = 0;
3718   destination->clsid             = source->propertyUniqueID;
3719   destination->grfStateBits      = 0;
3720   destination->reserved          = 0;
3721 }
3722
3723 /******************************************************************************
3724 ** BlockChainStream implementation
3725 */
3726
3727 BlockChainStream* BlockChainStream_Construct(
3728   Storage32Impl* parentStorage,
3729   ULONG*         headOfStreamPlaceHolder,
3730   ULONG          propertyIndex)
3731 {
3732   BlockChainStream* newStream;
3733
3734   newStream = HeapAlloc(GetProcessHeap(), 0, sizeof(BlockChainStream));
3735
3736   newStream->parentStorage           = parentStorage;
3737   newStream->headOfStreamPlaceHolder = headOfStreamPlaceHolder;
3738   newStream->ownerPropertyIndex      = propertyIndex;
3739
3740   return newStream;
3741 }
3742
3743 void BlockChainStream_Destroy(BlockChainStream* This)
3744 {
3745   HeapFree(GetProcessHeap(), 0, This);
3746 }
3747
3748 /******************************************************************************
3749  *      BlockChainStream_GetHeadOfChain
3750  *
3751  * Returns the head of this stream chain.
3752  * Some special chains don't have properties, their heads are kept in
3753  * This->headOfStreamPlaceHolder.
3754  *
3755  */
3756 ULONG BlockChainStream_GetHeadOfChain(BlockChainStream* This)
3757 {
3758   StgProperty chainProperty;
3759   BOOL32      readSucessful;
3760
3761   if (This->headOfStreamPlaceHolder != 0)
3762     return *(This->headOfStreamPlaceHolder);
3763
3764   if (This->ownerPropertyIndex != PROPERTY_NULL)
3765   {
3766     readSucessful = Storage32Impl_ReadProperty(
3767                       This->parentStorage,
3768                       This->ownerPropertyIndex,
3769                       &chainProperty);
3770
3771     if (readSucessful)
3772     {
3773       return chainProperty.startingBlock;
3774     }
3775   }
3776
3777   return BLOCK_END_OF_CHAIN;
3778 }
3779
3780 /******************************************************************************
3781  *       BlockChainStream_GetCount
3782  *
3783  * Returns the number of blocks that comprises this chain.
3784  * This is not the size of the stream as the last block may not be full!
3785  *
3786  */
3787 ULONG BlockChainStream_GetCount(BlockChainStream* This)
3788 {
3789   ULONG blockIndex;
3790   ULONG count = 0;
3791
3792   blockIndex = BlockChainStream_GetHeadOfChain(This);
3793
3794   while (blockIndex != BLOCK_END_OF_CHAIN)
3795   {
3796     count++;
3797
3798     blockIndex = Storage32Impl_GetNextBlockInChain(
3799                    This->parentStorage,
3800                    blockIndex);
3801   }
3802
3803   return count;
3804 }
3805
3806 /******************************************************************************
3807  *      BlockChainStream_ReadAt
3808  *
3809  * Reads a specified number of bytes from this chain at the specified offset.
3810  * bytesRead may be NULL.
3811  * Failure will be returned if the specified number of bytes has not been read.
3812  */
3813 BOOL32 BlockChainStream_ReadAt(BlockChainStream* This,
3814   ULARGE_INTEGER offset,
3815   ULONG          size,
3816   void*          buffer,
3817   ULONG*         bytesRead)
3818 {
3819   ULONG blockNoInSequence = offset.LowPart / This->parentStorage->bigBlockSize;
3820   ULONG offsetInBlock     = offset.LowPart % This->parentStorage->bigBlockSize;
3821   ULONG bytesToReadInBuffer;
3822   ULONG blockIndex;
3823   BYTE* bufferWalker;
3824   BYTE* bigBlockBuffer;
3825
3826   /*
3827    * Find the first block in the stream that contains part of the buffer.
3828    */
3829   blockIndex = BlockChainStream_GetHeadOfChain(This);
3830
3831   while ( (blockNoInSequence > 0) &&  (blockIndex != BLOCK_END_OF_CHAIN))
3832   {
3833     blockIndex =
3834       Storage32Impl_GetNextBlockInChain(This->parentStorage, blockIndex);
3835
3836     blockNoInSequence--;
3837   }
3838
3839   /*
3840    * Start reading the buffer.
3841    */
3842   *bytesRead   = 0;
3843   bufferWalker = buffer;
3844
3845   while ( (size > 0) && (blockIndex != BLOCK_END_OF_CHAIN) )
3846   {
3847     /*
3848      * Calculate how many bytes we can copy from this big block.
3849      */
3850     bytesToReadInBuffer =
3851       MIN(This->parentStorage->bigBlockSize - offsetInBlock, size);
3852
3853     /*
3854      * Copy those bytes to the buffer
3855      */
3856     bigBlockBuffer =
3857       Storage32Impl_GetROBigBlock(This->parentStorage, blockIndex);
3858
3859     memcpy(bufferWalker, bigBlockBuffer + offsetInBlock, bytesToReadInBuffer);
3860
3861     Storage32Impl_ReleaseBigBlock(This->parentStorage, bigBlockBuffer);
3862
3863     /*
3864      * Step to the next big block.
3865      */
3866     blockIndex    =
3867       Storage32Impl_GetNextBlockInChain(This->parentStorage, blockIndex);
3868
3869     bufferWalker += bytesToReadInBuffer;
3870     size         -= bytesToReadInBuffer;
3871     *bytesRead   += bytesToReadInBuffer;
3872     offsetInBlock = 0;  /* There is no offset on the next block */
3873
3874   }
3875
3876   return (size == 0);
3877 }
3878
3879 /******************************************************************************
3880  *      BlockChainStream_WriteAt
3881  *
3882  * Writes the specified number of bytes to this chain at the specified offset.
3883  * bytesWritten may be NULL.
3884  * Will fail if not all specified number of bytes have been written.
3885  */
3886 BOOL32 BlockChainStream_WriteAt(BlockChainStream* This,
3887   ULARGE_INTEGER    offset,
3888   ULONG             size,
3889   const void*       buffer,
3890   ULONG*            bytesWritten)
3891 {
3892   ULONG blockNoInSequence = offset.LowPart / This->parentStorage->bigBlockSize;
3893   ULONG offsetInBlock     = offset.LowPart % This->parentStorage->bigBlockSize;
3894   ULONG bytesToWrite;
3895   ULONG blockIndex;
3896   BYTE* bufferWalker;
3897   BYTE* bigBlockBuffer;
3898
3899   /*
3900    * Find the first block in the stream that contains part of the buffer.
3901    */
3902   blockIndex = BlockChainStream_GetHeadOfChain(This);
3903
3904   while ( (blockNoInSequence > 0) &&  (blockIndex != BLOCK_END_OF_CHAIN))
3905   {
3906     blockIndex =
3907       Storage32Impl_GetNextBlockInChain(This->parentStorage, blockIndex);
3908
3909     blockNoInSequence--;
3910   }
3911
3912   /*
3913    * Here, I'm casting away the constness on the buffer variable
3914    * This is OK since we don't intend to modify that buffer.
3915    */
3916   *bytesWritten   = 0;
3917   bufferWalker = (BYTE*)buffer;
3918
3919   while ( (size > 0) && (blockIndex != BLOCK_END_OF_CHAIN) )
3920   {
3921     /*
3922      * Calculate how many bytes we can copy from this big block.
3923      */
3924     bytesToWrite =
3925       MIN(This->parentStorage->bigBlockSize - offsetInBlock, size);
3926
3927     /*
3928      * Copy those bytes to the buffer
3929      */
3930     bigBlockBuffer = Storage32Impl_GetBigBlock(This->parentStorage, blockIndex);
3931
3932     memcpy(bigBlockBuffer + offsetInBlock, bufferWalker, bytesToWrite);
3933
3934     Storage32Impl_ReleaseBigBlock(This->parentStorage, bigBlockBuffer);
3935
3936     /*
3937      * Step to the next big block.
3938      */
3939     blockIndex    =
3940       Storage32Impl_GetNextBlockInChain(This->parentStorage, blockIndex);
3941
3942     bufferWalker  += bytesToWrite;
3943     size          -= bytesToWrite;
3944     *bytesWritten += bytesToWrite;
3945     offsetInBlock  = 0;      /* There is no offset on the next block */
3946   }
3947
3948   return (size == 0);
3949 }
3950
3951 /******************************************************************************
3952  *      BlockChainStream_Shrink
3953  *
3954  * Shrinks this chain in the big block depot.
3955  */
3956 BOOL32 BlockChainStream_Shrink(BlockChainStream* This,
3957                                ULARGE_INTEGER    newSize)
3958 {
3959   ULONG blockIndex, extraBlock;
3960   ULONG numBlocks;
3961   ULONG count = 1;
3962
3963   /*
3964    * Figure out how many blocks are needed to contain the new size
3965    */
3966   numBlocks = newSize.LowPart / This->parentStorage->bigBlockSize;
3967
3968   if ((newSize.LowPart % This->parentStorage->bigBlockSize) != 0)
3969     numBlocks++;
3970
3971   blockIndex = BlockChainStream_GetHeadOfChain(This);
3972
3973   /*
3974    * Go to the new end of chain
3975    */
3976   while (count < numBlocks)
3977   {
3978     blockIndex =
3979       Storage32Impl_GetNextBlockInChain(This->parentStorage, blockIndex);
3980
3981     count++;
3982   }
3983
3984   /* Get the next block before marking the new end */
3985   extraBlock =
3986     Storage32Impl_GetNextBlockInChain(This->parentStorage, blockIndex);
3987
3988   /* Mark the new end of chain */
3989   Storage32Impl_SetNextBlockInChain(
3990     This->parentStorage,
3991     blockIndex,
3992     BLOCK_END_OF_CHAIN);
3993
3994   /*
3995    * Mark the extra blocks as free
3996    */
3997   while (extraBlock != BLOCK_END_OF_CHAIN)
3998   {
3999     blockIndex =
4000       Storage32Impl_GetNextBlockInChain(This->parentStorage, extraBlock);
4001
4002     Storage32Impl_FreeBigBlock(This->parentStorage, extraBlock);
4003     extraBlock = blockIndex;
4004   }
4005
4006   return TRUE;
4007 }
4008
4009 /******************************************************************************
4010  *      BlockChainStream_Enlarge
4011  *
4012  * Grows this chain in the big block depot.
4013  */
4014 BOOL32 BlockChainStream_Enlarge(BlockChainStream* This,
4015                                 ULARGE_INTEGER    newSize)
4016 {
4017   ULONG blockIndex, currentBlock;
4018   ULONG newNumBlocks;
4019   ULONG oldNumBlocks = 0;
4020
4021   blockIndex = BlockChainStream_GetHeadOfChain(This);
4022
4023   /*
4024    * Empty chain. Create the head.
4025    */
4026   if (blockIndex == BLOCK_END_OF_CHAIN)
4027   {
4028     blockIndex = Storage32Impl_GetNextFreeBigBlock(This->parentStorage);
4029     Storage32Impl_SetNextBlockInChain(This->parentStorage,
4030                                       blockIndex,
4031                                       BLOCK_END_OF_CHAIN);
4032
4033     if (This->headOfStreamPlaceHolder != 0)
4034     {
4035       *(This->headOfStreamPlaceHolder) = blockIndex;
4036     }
4037     else
4038     {
4039     StgProperty chainProp;
4040     assert(This->ownerPropertyIndex != PROPERTY_NULL);
4041
4042     Storage32Impl_ReadProperty(
4043       This->parentStorage,
4044       This->ownerPropertyIndex,
4045       &chainProp);
4046
4047       chainProp.startingBlock = blockIndex;
4048
4049     Storage32Impl_WriteProperty(
4050       This->parentStorage,
4051       This->ownerPropertyIndex,
4052       &chainProp);
4053   }
4054   }
4055
4056   currentBlock = blockIndex;
4057
4058   /*
4059    * Figure out how many blocks are needed to contain this stream
4060    */
4061   newNumBlocks = newSize.LowPart / This->parentStorage->bigBlockSize;
4062
4063   if ((newSize.LowPart % This->parentStorage->bigBlockSize) != 0)
4064     newNumBlocks++;
4065
4066   /*
4067    * Go to the current end of chain
4068    */
4069   while (blockIndex != BLOCK_END_OF_CHAIN)
4070   {
4071     oldNumBlocks++;
4072     currentBlock = blockIndex;
4073
4074     blockIndex =
4075       Storage32Impl_GetNextBlockInChain(This->parentStorage, currentBlock);
4076   }
4077
4078   /*
4079    * Add new blocks to the chain
4080    */
4081   while (oldNumBlocks < newNumBlocks)
4082   {
4083     blockIndex = Storage32Impl_GetNextFreeBigBlock(This->parentStorage);
4084
4085     Storage32Impl_SetNextBlockInChain(
4086       This->parentStorage,
4087       currentBlock,
4088       blockIndex);
4089
4090     Storage32Impl_SetNextBlockInChain(
4091       This->parentStorage,
4092       blockIndex,
4093       BLOCK_END_OF_CHAIN);
4094
4095     currentBlock = blockIndex;
4096     oldNumBlocks++;
4097   }
4098
4099   return TRUE;
4100 }
4101
4102 /******************************************************************************
4103  *      BlockChainStream_SetSize
4104  *
4105  * Sets the size of this stream. The big block depot will be updated.
4106  * The file will grow if we grow the chain.
4107  *
4108  * TODO: Free the actual blocks in the file when we shrink the chain.
4109  *       Currently, the blocks are still in the file. So the file size
4110  *       doesn't shrink even if we shrink streams.
4111  */
4112 BOOL32 BlockChainStream_SetSize(
4113   BlockChainStream* This,
4114   ULARGE_INTEGER    newSize)
4115 {
4116   ULARGE_INTEGER size = BlockChainStream_GetSize(This);
4117
4118   if (newSize.LowPart == size.LowPart)
4119     return TRUE;
4120
4121   if (newSize.LowPart < size.LowPart)
4122   {
4123     BlockChainStream_Shrink(This, newSize);
4124   }
4125   else
4126   {
4127     ULARGE_INTEGER fileSize =
4128       BIGBLOCKFILE_GetSize(This->parentStorage->bigBlockFile);
4129
4130     ULONG diff = newSize.LowPart - size.LowPart;
4131
4132     /*
4133      * Make sure the file stays a multiple of blocksize
4134      */
4135     if ((diff % This->parentStorage->bigBlockSize) != 0)
4136       diff += (This->parentStorage->bigBlockSize -
4137                 (diff % This->parentStorage->bigBlockSize) );
4138
4139     fileSize.LowPart += diff;
4140     BIGBLOCKFILE_SetSize(This->parentStorage->bigBlockFile, fileSize);
4141
4142     BlockChainStream_Enlarge(This, newSize);
4143   }
4144
4145   return TRUE;
4146 }
4147
4148 /******************************************************************************
4149  *      BlockChainStream_GetSize
4150  *
4151  * Returns the size of this chain.
4152  * Will return the block count if this chain doesn't have a property.
4153  */
4154 ULARGE_INTEGER BlockChainStream_GetSize(BlockChainStream* This)
4155 {
4156   StgProperty chainProperty;
4157
4158   if(This->headOfStreamPlaceHolder == NULL)
4159   {
4160     /*
4161      * This chain is a data stream read the property and return
4162      * the appropriate size
4163      */
4164     Storage32Impl_ReadProperty(
4165       This->parentStorage,
4166       This->ownerPropertyIndex,
4167       &chainProperty);
4168
4169     return chainProperty.size;
4170   }
4171   else
4172   {
4173     /*
4174      * this chain is a chain that does not have a property, figure out the
4175      * size by making the product number of used blocks times the
4176      * size of them
4177      */
4178     ULARGE_INTEGER result;
4179     result.HighPart = 0;
4180
4181     result.LowPart  =
4182       BlockChainStream_GetCount(This) *
4183       This->parentStorage->bigBlockSize;
4184
4185     return result;
4186   }
4187 }
4188
4189 /******************************************************************************
4190 ** SmallBlockChainStream implementation
4191 */
4192
4193 SmallBlockChainStream* SmallBlockChainStream_Construct(
4194   Storage32Impl* parentStorage,
4195   ULONG          propertyIndex)
4196 {
4197   SmallBlockChainStream* newStream;
4198
4199   newStream = HeapAlloc(GetProcessHeap(), 0, sizeof(SmallBlockChainStream));
4200
4201   newStream->parentStorage      = parentStorage;
4202   newStream->ownerPropertyIndex = propertyIndex;
4203
4204   return newStream;
4205 }
4206
4207 void SmallBlockChainStream_Destroy(
4208   SmallBlockChainStream* This)
4209 {
4210   HeapFree(GetProcessHeap(), 0, This);
4211 }
4212
4213 /******************************************************************************
4214  *      SmallBlockChainStream_GetHeadOfChain
4215  *
4216  * Returns the head of this chain of small blocks.
4217  */
4218 ULONG SmallBlockChainStream_GetHeadOfChain(
4219   SmallBlockChainStream* This)
4220 {
4221   StgProperty chainProperty;
4222   BOOL32      readSucessful;
4223
4224   if (This->ownerPropertyIndex)
4225   {
4226     readSucessful = Storage32Impl_ReadProperty(
4227                       This->parentStorage,
4228                       This->ownerPropertyIndex,
4229                       &chainProperty);
4230
4231     if (readSucessful)
4232     {
4233       return chainProperty.startingBlock;
4234     }
4235
4236   }
4237
4238   return BLOCK_END_OF_CHAIN;
4239 }
4240
4241 /******************************************************************************
4242  *      SmallBlockChainStream_GetNextBlockInChain
4243  *
4244  * Returns the index of the next small block in this chain.
4245  *
4246  * Return Values:
4247  *    - BLOCK_END_OF_CHAIN: end of this chain
4248  *    - BLOCK_UNUSED: small block 'blockIndex' is free
4249  */
4250 ULONG SmallBlockChainStream_GetNextBlockInChain(
4251   SmallBlockChainStream* This,
4252   ULONG                  blockIndex)
4253 {
4254   ULARGE_INTEGER offsetOfBlockInDepot;
4255   DWORD  buffer;
4256   ULONG  nextBlockInChain = BLOCK_END_OF_CHAIN;
4257   ULONG  bytesRead;
4258   BOOL32 success;
4259
4260   offsetOfBlockInDepot.HighPart = 0;
4261   offsetOfBlockInDepot.LowPart  = blockIndex * sizeof(ULONG);
4262
4263   /*
4264    * Read those bytes in the buffer from the small block file.
4265    */
4266   success = BlockChainStream_ReadAt(
4267               This->parentStorage->smallBlockDepotChain,
4268               offsetOfBlockInDepot,
4269               sizeof(DWORD),
4270               &buffer,
4271               &bytesRead);
4272
4273   if (success)
4274   {
4275     StorageUtl_ReadDWord(&buffer, 0, &nextBlockInChain);
4276   }
4277
4278   return nextBlockInChain;
4279 }
4280
4281 /******************************************************************************
4282  *       SmallBlockChainStream_SetNextBlockInChain
4283  *
4284  * Writes the index of the next block of the specified block in the small
4285  * block depot.
4286  * To set the end of chain use BLOCK_END_OF_CHAIN as nextBlock.
4287  * To flag a block as free use BLOCK_UNUSED as nextBlock.
4288  */
4289 void SmallBlockChainStream_SetNextBlockInChain(
4290   SmallBlockChainStream* This,
4291   ULONG                  blockIndex,
4292   ULONG                  nextBlock)
4293 {
4294   ULARGE_INTEGER offsetOfBlockInDepot;
4295   DWORD  buffer;
4296   ULONG  bytesWritten;
4297
4298   offsetOfBlockInDepot.HighPart = 0;
4299   offsetOfBlockInDepot.LowPart  = blockIndex * sizeof(ULONG);
4300
4301   StorageUtl_WriteDWord(&buffer, 0, nextBlock);
4302
4303   /*
4304    * Read those bytes in the buffer from the small block file.
4305    */
4306   BlockChainStream_WriteAt(
4307     This->parentStorage->smallBlockDepotChain,
4308     offsetOfBlockInDepot,
4309     sizeof(DWORD),
4310     &buffer,
4311     &bytesWritten);
4312 }
4313
4314 /******************************************************************************
4315  *      SmallBlockChainStream_FreeBlock
4316  *
4317  * Flag small block 'blockIndex' as free in the small block depot.
4318  */
4319 void SmallBlockChainStream_FreeBlock(
4320   SmallBlockChainStream* This,
4321   ULONG                  blockIndex)
4322 {
4323   SmallBlockChainStream_SetNextBlockInChain(This, blockIndex, BLOCK_UNUSED);
4324 }
4325
4326 /******************************************************************************
4327  *      SmallBlockChainStream_GetNextFreeBlock
4328  *
4329  * Returns the index of a free small block. The small block depot will be
4330  * enlarged if necessary. The small block chain will also be enlarged if
4331  * necessary.
4332  */
4333 ULONG SmallBlockChainStream_GetNextFreeBlock(
4334   SmallBlockChainStream* This)
4335 {
4336   ULARGE_INTEGER offsetOfBlockInDepot;
4337   DWORD buffer;
4338   ULONG bytesRead;
4339   ULONG blockIndex = 0;
4340   ULONG nextBlockIndex = BLOCK_END_OF_CHAIN;
4341   BOOL32 success = TRUE;
4342   ULONG smallBlocksPerBigBlock;
4343
4344   offsetOfBlockInDepot.HighPart = 0;
4345
4346   /*
4347    * Scan the small block depot for a free block
4348    */
4349   while (nextBlockIndex != BLOCK_UNUSED)
4350   {
4351     offsetOfBlockInDepot.LowPart = blockIndex * sizeof(ULONG);
4352
4353     success = BlockChainStream_ReadAt(
4354                 This->parentStorage->smallBlockDepotChain,
4355                 offsetOfBlockInDepot,
4356                 sizeof(DWORD),
4357                 &buffer,
4358                 &bytesRead);
4359
4360     /*
4361      * If we run out of space for the small block depot, enlarge it
4362      */
4363     if (success)
4364     {
4365       StorageUtl_ReadDWord(&buffer, 0, &nextBlockIndex);
4366
4367       if (nextBlockIndex != BLOCK_UNUSED)
4368         blockIndex++;
4369     }
4370     else
4371     {
4372       ULONG count =
4373         BlockChainStream_GetCount(This->parentStorage->smallBlockDepotChain);
4374
4375       ULONG sbdIndex = This->parentStorage->smallBlockDepotStart;
4376       ULONG nextBlock, newsbdIndex;
4377       BYTE* smallBlockDepot;
4378
4379       nextBlock = sbdIndex;
4380       while (nextBlock != BLOCK_END_OF_CHAIN)
4381       {
4382         sbdIndex = nextBlock;
4383         nextBlock =
4384           Storage32Impl_GetNextBlockInChain(This->parentStorage, sbdIndex);
4385       }
4386
4387       newsbdIndex = Storage32Impl_GetNextFreeBigBlock(This->parentStorage);
4388       if (sbdIndex != BLOCK_END_OF_CHAIN)
4389         Storage32Impl_SetNextBlockInChain(
4390           This->parentStorage,
4391           sbdIndex,
4392           newsbdIndex);
4393
4394       Storage32Impl_SetNextBlockInChain(
4395         This->parentStorage,
4396         newsbdIndex,
4397         BLOCK_END_OF_CHAIN);
4398
4399       /*
4400        * Initialize all the small blocks to free
4401        */
4402       smallBlockDepot =
4403         Storage32Impl_GetBigBlock(This->parentStorage, newsbdIndex);
4404
4405       memset(smallBlockDepot, BLOCK_UNUSED, This->parentStorage->bigBlockSize);
4406       Storage32Impl_ReleaseBigBlock(This->parentStorage, smallBlockDepot);
4407
4408       if (count == 0)
4409       {
4410         /*
4411          * We have just created the small block depot.
4412          */
4413         StgProperty rootProp;
4414         ULONG sbStartIndex;
4415
4416         /*
4417          * Save it in the header
4418          */
4419         This->parentStorage->smallBlockDepotStart = newsbdIndex;
4420         Storage32Impl_SaveFileHeader(This->parentStorage);
4421
4422         /*
4423          * And allocate the first big block that will contain small blocks
4424          */
4425         sbStartIndex =
4426           Storage32Impl_GetNextFreeBigBlock(This->parentStorage);
4427
4428         Storage32Impl_SetNextBlockInChain(
4429           This->parentStorage,
4430           sbStartIndex,
4431           BLOCK_END_OF_CHAIN);
4432
4433         Storage32Impl_ReadProperty(
4434           This->parentStorage,
4435           This->parentStorage->rootPropertySetIndex,
4436           &rootProp);
4437
4438         rootProp.startingBlock = sbStartIndex;
4439         rootProp.size.HighPart = 0;
4440         rootProp.size.LowPart  = This->parentStorage->bigBlockSize;
4441
4442         Storage32Impl_WriteProperty(
4443           This->parentStorage,
4444           This->parentStorage->rootPropertySetIndex,
4445           &rootProp);
4446       }
4447     }
4448   }
4449
4450   smallBlocksPerBigBlock =
4451     This->parentStorage->bigBlockSize / This->parentStorage->smallBlockSize;
4452
4453   /*
4454    * Verify if we have to allocate big blocks to contain small blocks
4455    */
4456   if (blockIndex % smallBlocksPerBigBlock == 0)
4457   {
4458     StgProperty rootProp;
4459     ULONG blocksRequired = (blockIndex / smallBlocksPerBigBlock) + 1;
4460
4461     Storage32Impl_ReadProperty(
4462       This->parentStorage,
4463       This->parentStorage->rootPropertySetIndex,
4464       &rootProp);
4465
4466     if (rootProp.size.LowPart <
4467        (blocksRequired * This->parentStorage->bigBlockSize))
4468     {
4469       rootProp.size.LowPart += This->parentStorage->bigBlockSize;
4470
4471       BlockChainStream_SetSize(
4472         This->parentStorage->smallBlockRootChain,
4473         rootProp.size);
4474
4475       Storage32Impl_WriteProperty(
4476         This->parentStorage,
4477         This->parentStorage->rootPropertySetIndex,
4478         &rootProp);
4479     }
4480   }
4481
4482   return blockIndex;
4483 }
4484
4485 /******************************************************************************
4486  *      SmallBlockChainStream_ReadAt
4487  *
4488  * Reads a specified number of bytes from this chain at the specified offset.
4489  * bytesRead may be NULL.
4490  * Failure will be returned if the specified number of bytes has not been read.
4491  */
4492 BOOL32 SmallBlockChainStream_ReadAt(
4493   SmallBlockChainStream* This,
4494   ULARGE_INTEGER         offset,
4495   ULONG                  size,
4496   void*                  buffer,
4497   ULONG*                 bytesRead)
4498 {
4499   ULARGE_INTEGER offsetInBigBlockFile;
4500   ULONG blockNoInSequence =
4501     offset.LowPart / This->parentStorage->smallBlockSize;
4502
4503   ULONG offsetInBlock = offset.LowPart % This->parentStorage->smallBlockSize;
4504   ULONG bytesToReadInBuffer;
4505   ULONG blockIndex;
4506   ULONG bytesReadFromBigBlockFile;
4507   BYTE* bufferWalker;
4508
4509   /*
4510    * This should never happen on a small block file.
4511    */
4512   assert(offset.HighPart==0);
4513
4514   /*
4515    * Find the first block in the stream that contains part of the buffer.
4516    */
4517   blockIndex = SmallBlockChainStream_GetHeadOfChain(This);
4518
4519   while ( (blockNoInSequence > 0) &&  (blockIndex != BLOCK_END_OF_CHAIN))
4520   {
4521     blockIndex = SmallBlockChainStream_GetNextBlockInChain(This, blockIndex);
4522
4523     blockNoInSequence--;
4524   }
4525
4526   /*
4527    * Start reading the buffer.
4528    */
4529   *bytesRead   = 0;
4530   bufferWalker = buffer;
4531
4532   while ( (size > 0) && (blockIndex != BLOCK_END_OF_CHAIN) )
4533   {
4534     /*
4535      * Calculate how many bytes we can copy from this small block.
4536      */
4537     bytesToReadInBuffer =
4538       MIN(This->parentStorage->smallBlockSize - offsetInBlock, size);
4539
4540     /*
4541      * Calculate the offset of the small block in the small block file.
4542      */
4543     offsetInBigBlockFile.HighPart  = 0;
4544     offsetInBigBlockFile.LowPart   =
4545       blockIndex * This->parentStorage->smallBlockSize;
4546
4547     offsetInBigBlockFile.LowPart  += offsetInBlock;
4548
4549     /*
4550      * Read those bytes in the buffer from the small block file.
4551      */
4552     BlockChainStream_ReadAt(This->parentStorage->smallBlockRootChain,
4553       offsetInBigBlockFile,
4554       bytesToReadInBuffer,
4555       bufferWalker,
4556       &bytesReadFromBigBlockFile);
4557
4558     assert(bytesReadFromBigBlockFile == bytesToReadInBuffer);
4559
4560     /*
4561      * Step to the next big block.
4562      */
4563     blockIndex    = SmallBlockChainStream_GetNextBlockInChain(This, blockIndex);
4564     bufferWalker += bytesToReadInBuffer;
4565     size         -= bytesToReadInBuffer;
4566     *bytesRead   += bytesToReadInBuffer;
4567     offsetInBlock = 0;  /* There is no offset on the next block */
4568   }
4569
4570   return (size == 0);
4571 }
4572
4573 /******************************************************************************
4574  *       SmallBlockChainStream_WriteAt
4575  *
4576  * Writes the specified number of bytes to this chain at the specified offset.
4577  * bytesWritten may be NULL.
4578  * Will fail if not all specified number of bytes have been written.
4579  */
4580 BOOL32 SmallBlockChainStream_WriteAt(
4581   SmallBlockChainStream* This,
4582   ULARGE_INTEGER offset,
4583   ULONG          size,
4584   const void*    buffer,
4585   ULONG*         bytesWritten)
4586 {
4587   ULARGE_INTEGER offsetInBigBlockFile;
4588   ULONG blockNoInSequence =
4589     offset.LowPart / This->parentStorage->smallBlockSize;
4590
4591   ULONG offsetInBlock = offset.LowPart % This->parentStorage->smallBlockSize;
4592   ULONG bytesToWriteInBuffer;
4593   ULONG blockIndex;
4594   ULONG bytesWrittenFromBigBlockFile;
4595   BYTE* bufferWalker;
4596
4597   /*
4598    * This should never happen on a small block file.
4599    */
4600   assert(offset.HighPart==0);
4601
4602   /*
4603    * Find the first block in the stream that contains part of the buffer.
4604    */
4605   blockIndex = SmallBlockChainStream_GetHeadOfChain(This);
4606
4607   while ( (blockNoInSequence > 0) &&  (blockIndex != BLOCK_END_OF_CHAIN))
4608   {
4609     blockIndex = SmallBlockChainStream_GetNextBlockInChain(This, blockIndex);
4610
4611     blockNoInSequence--;
4612   }
4613
4614   /*
4615    * Start writing the buffer.
4616    *
4617    * Here, I'm casting away the constness on the buffer variable
4618    * This is OK since we don't intend to modify that buffer.
4619    */
4620   *bytesWritten   = 0;
4621   bufferWalker = (BYTE*)buffer;
4622   while ( (size > 0) && (blockIndex != BLOCK_END_OF_CHAIN) )
4623   {
4624     /*
4625      * Calculate how many bytes we can copy to this small block.
4626      */
4627     bytesToWriteInBuffer =
4628       MIN(This->parentStorage->smallBlockSize - offsetInBlock, size);
4629
4630     /*
4631      * Calculate the offset of the small block in the small block file.
4632      */
4633     offsetInBigBlockFile.HighPart  = 0;
4634     offsetInBigBlockFile.LowPart   =
4635       blockIndex * This->parentStorage->smallBlockSize;
4636
4637     offsetInBigBlockFile.LowPart  += offsetInBlock;
4638
4639     /*
4640      * Write those bytes in the buffer to the small block file.
4641      */
4642     BlockChainStream_WriteAt(This->parentStorage->smallBlockRootChain,
4643       offsetInBigBlockFile,
4644       bytesToWriteInBuffer,
4645       bufferWalker,
4646       &bytesWrittenFromBigBlockFile);
4647
4648     assert(bytesWrittenFromBigBlockFile == bytesToWriteInBuffer);
4649
4650     /*
4651      * Step to the next big block.
4652      */
4653     blockIndex    = SmallBlockChainStream_GetNextBlockInChain(This, blockIndex);
4654     bufferWalker  += bytesToWriteInBuffer;
4655     size          -= bytesToWriteInBuffer;
4656     *bytesWritten += bytesToWriteInBuffer;
4657     offsetInBlock  = 0;     /* There is no offset on the next block */
4658   }
4659
4660   return (size == 0);
4661 }
4662
4663 /******************************************************************************
4664  *       SmallBlockChainStream_Shrink
4665  *
4666  * Shrinks this chain in the small block depot.
4667  */
4668 BOOL32 SmallBlockChainStream_Shrink(
4669   SmallBlockChainStream* This,
4670   ULARGE_INTEGER newSize)
4671 {
4672   ULONG blockIndex, extraBlock;
4673   ULONG numBlocks;
4674   ULONG count = 1;
4675
4676   numBlocks = newSize.LowPart / This->parentStorage->smallBlockSize;
4677
4678   if ((newSize.LowPart % This->parentStorage->smallBlockSize) != 0)
4679     numBlocks++;
4680
4681   blockIndex = SmallBlockChainStream_GetHeadOfChain(This);
4682
4683   /*
4684    * Go to the new end of chain
4685    */
4686   while (count < numBlocks)
4687   {
4688     blockIndex = SmallBlockChainStream_GetNextBlockInChain(This, blockIndex);
4689     count++;
4690   }
4691
4692   /* Get the next block before marking the new end */
4693   extraBlock = SmallBlockChainStream_GetNextBlockInChain(This, blockIndex);
4694
4695   /* Mark the new end of chain */
4696   SmallBlockChainStream_SetNextBlockInChain(
4697     This,
4698     blockIndex,
4699     BLOCK_END_OF_CHAIN);
4700
4701   /*
4702    * Mark the extra blocks as free
4703    */
4704   while (extraBlock != BLOCK_END_OF_CHAIN)
4705   {
4706     blockIndex = SmallBlockChainStream_GetNextBlockInChain(This, extraBlock);
4707     SmallBlockChainStream_FreeBlock(This, extraBlock);
4708     extraBlock = blockIndex;
4709   }
4710
4711   return TRUE;
4712 }
4713
4714 /******************************************************************************
4715  *      SmallBlockChainStream_Enlarge
4716  *
4717  * Grows this chain in the small block depot.
4718  */
4719 BOOL32 SmallBlockChainStream_Enlarge(
4720   SmallBlockChainStream* This,
4721   ULARGE_INTEGER newSize)
4722 {
4723   ULONG blockIndex, currentBlock;
4724   ULONG newNumBlocks;
4725   ULONG oldNumBlocks = 0;
4726
4727   blockIndex = SmallBlockChainStream_GetHeadOfChain(This);
4728
4729   /*
4730    * Empty chain
4731    */
4732   if (blockIndex == BLOCK_END_OF_CHAIN)
4733   {
4734     StgProperty chainProp;
4735
4736     Storage32Impl_ReadProperty(This->parentStorage, This->ownerPropertyIndex,
4737                                &chainProp);
4738
4739     chainProp.startingBlock = SmallBlockChainStream_GetNextFreeBlock(This);
4740
4741     Storage32Impl_WriteProperty(This->parentStorage, This->ownerPropertyIndex,
4742                                 &chainProp);
4743
4744     blockIndex = chainProp.startingBlock;
4745     SmallBlockChainStream_SetNextBlockInChain(
4746       This,
4747       blockIndex,
4748       BLOCK_END_OF_CHAIN);
4749   }
4750
4751   currentBlock = blockIndex;
4752
4753   /*
4754    * Figure out how many blocks are needed to contain this stream
4755    */
4756   newNumBlocks = newSize.LowPart / This->parentStorage->smallBlockSize;
4757
4758   if ((newSize.LowPart % This->parentStorage->smallBlockSize) != 0)
4759     newNumBlocks++;
4760
4761   /*
4762    * Go to the current end of chain
4763    */
4764   while (blockIndex != BLOCK_END_OF_CHAIN)
4765   {
4766     oldNumBlocks++;
4767     currentBlock = blockIndex;
4768     blockIndex = SmallBlockChainStream_GetNextBlockInChain(This, currentBlock);
4769   }
4770
4771   /*
4772    * Add new blocks to the chain
4773    */
4774   while (oldNumBlocks < newNumBlocks)
4775   {
4776     blockIndex = SmallBlockChainStream_GetNextFreeBlock(This);
4777     SmallBlockChainStream_SetNextBlockInChain(This, currentBlock, blockIndex);
4778
4779     SmallBlockChainStream_SetNextBlockInChain(
4780       This,
4781       blockIndex,
4782       BLOCK_END_OF_CHAIN);
4783
4784     currentBlock = blockIndex;
4785     oldNumBlocks++;
4786   }
4787
4788   return TRUE;
4789 }
4790
4791 /******************************************************************************
4792  *      SmallBlockChainStream_GetCount
4793  *
4794  * Returns the number of blocks that comprises this chain.
4795  * This is not the size of this chain as the last block may not be full!
4796  */
4797 ULONG SmallBlockChainStream_GetCount(SmallBlockChainStream* This)
4798 {
4799   ULONG blockIndex;
4800   ULONG count = 0;
4801
4802   blockIndex = SmallBlockChainStream_GetHeadOfChain(This);
4803
4804   while (blockIndex != BLOCK_END_OF_CHAIN)
4805   {
4806     count++;
4807
4808     blockIndex = SmallBlockChainStream_GetNextBlockInChain(This, blockIndex);
4809   }
4810
4811   return count;
4812 }
4813
4814 /******************************************************************************
4815  *      SmallBlockChainStream_SetSize
4816  *
4817  * Sets the size of this stream.
4818  * The file will grow if we grow the chain.
4819  *
4820  * TODO: Free the actual blocks in the file when we shrink the chain.
4821  *       Currently, the blocks are still in the file. So the file size
4822  *       doesn't shrink even if we shrink streams.
4823  */
4824 BOOL32 SmallBlockChainStream_SetSize(
4825                 SmallBlockChainStream* This,
4826                 ULARGE_INTEGER    newSize)
4827 {
4828   ULARGE_INTEGER size = SmallBlockChainStream_GetSize(This);
4829
4830   if (newSize.LowPart == size.LowPart)
4831     return TRUE;
4832
4833   if (newSize.LowPart < size.LowPart)
4834   {
4835     SmallBlockChainStream_Shrink(This, newSize);
4836   }
4837   else
4838   {
4839     SmallBlockChainStream_Enlarge(This, newSize);
4840   }
4841
4842   return TRUE;
4843 }
4844
4845 /******************************************************************************
4846  *      SmallBlockChainStream_GetSize
4847  *
4848  * Returns the size of this chain.
4849  */
4850 ULARGE_INTEGER SmallBlockChainStream_GetSize(SmallBlockChainStream* This)
4851 {
4852   StgProperty chainProperty;
4853
4854   Storage32Impl_ReadProperty(
4855     This->parentStorage,
4856     This->ownerPropertyIndex,
4857     &chainProperty);
4858
4859   return chainProperty.size;
4860 }
4861
4862 /******************************************************************************
4863  *    StgCreateDocfile32  [OLE32.144]
4864  *    TODO Validate grfMode (STGM)
4865  */
4866 HRESULT WINAPI StgCreateDocfile32(
4867   LPCOLESTR32 pwcsName,
4868   DWORD       grfMode,
4869   DWORD       reserved,
4870   IStorage32  **ppstgOpen)
4871 {
4872   Storage32Impl* newStorage = 0;
4873   HANDLE32       hFile      = INVALID_HANDLE_VALUE32;
4874   HRESULT        hr         = S_OK;
4875   DWORD          shareMode;
4876   DWORD          accessMode;
4877   DWORD          creationMode;
4878   DWORD          fileAttributes;
4879
4880   /*
4881    * Validate the parameters
4882    */
4883   if ((ppstgOpen == 0) || (pwcsName == 0))
4884     return STG_E_INVALIDPOINTER;
4885
4886   /*
4887    * Validate the STGM flags
4888    */
4889   if ( FAILED( validateSTGM(grfMode) ))
4890     return STG_E_INVALIDFLAG;
4891
4892   /*
4893    * Interpret the STGM value grfMode
4894    */
4895   shareMode    = GetShareModeFromSTGM(grfMode);
4896   accessMode   = GetAccessModeFromSTGM(grfMode);
4897   creationMode = GetCreationModeFromSTGM(grfMode);
4898
4899   if (grfMode & STGM_DELETEONRELEASE)
4900     fileAttributes = FILE_FLAG_RANDOM_ACCESS | FILE_FLAG_DELETE_ON_CLOSE;
4901   else
4902     fileAttributes = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS;
4903
4904   if (grfMode & STGM_TRANSACTED)
4905     FIXME(ole, "Transacted mode not implemented.\n");
4906
4907   /*
4908    * Initialize the "out" parameter.
4909    */
4910   *ppstgOpen = 0;
4911
4912   hFile = CreateFile32W(pwcsName,
4913                         accessMode,
4914                         shareMode,
4915             NULL,
4916                         creationMode,
4917                         fileAttributes,
4918             0);
4919
4920   if (hFile == INVALID_HANDLE_VALUE32)
4921   {
4922     return E_FAIL;
4923   }
4924
4925   /*
4926    * Allocate and initialize the new IStorage32object.
4927    */
4928   newStorage = HeapAlloc(GetProcessHeap(), 0, sizeof(Storage32Impl));
4929
4930   if (newStorage == 0)
4931     return STG_E_INSUFFICIENTMEMORY;
4932
4933   hr = Storage32Impl_Construct(
4934          newStorage,
4935          hFile,
4936          grfMode);
4937
4938   if (FAILED(hr))
4939     return hr;
4940
4941   /*
4942    * Get an "out" pointer for the caller.
4943    */
4944   hr = Storage32BaseImpl_QueryInterface(
4945          (IStorage32*)newStorage,
4946          (REFIID)&IID_IStorage,
4947          (void**)ppstgOpen);
4948
4949   return hr;
4950 }
4951
4952 /******************************************************************************
4953  *              StgOpenStorage32        [OLE32.148]
4954  */
4955 HRESULT WINAPI StgOpenStorage32(
4956   const OLECHAR32 *pwcsName,
4957   IStorage32      *pstgPriority,
4958   DWORD           grfMode,
4959   SNB32           snbExclude,
4960   DWORD           reserved,
4961   IStorage32      **ppstgOpen)
4962 {
4963   Storage32Impl* newStorage = 0;
4964   HRESULT        hr = S_OK;
4965   HANDLE32       hFile = 0;
4966   DWORD          shareMode;
4967   DWORD          accessMode;
4968
4969   /*
4970    * Perform a sanity check
4971    */
4972   if (( pwcsName == 0) || (ppstgOpen == 0) )
4973     return STG_E_INVALIDPOINTER;
4974
4975   /*
4976    * Validate the STGM flags
4977    */
4978   if ( FAILED( validateSTGM(grfMode) ))
4979     return STG_E_INVALIDFLAG;
4980
4981   /*
4982    * Interpret the STGM value grfMode
4983    */
4984   shareMode    = GetShareModeFromSTGM(grfMode);
4985   accessMode   = GetAccessModeFromSTGM(grfMode);
4986
4987   /*
4988    * Initialize the "out" parameter.
4989    */
4990   *ppstgOpen = 0;
4991
4992   hFile = CreateFile32W( pwcsName,
4993                         accessMode,
4994                         shareMode,
4995             NULL,
4996             OPEN_EXISTING,
4997             FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
4998             0);
4999
5000
5001   if (hFile==INVALID_HANDLE_VALUE32)
5002   {
5003     return E_FAIL;
5004   }
5005
5006   /*
5007    * Allocate and initialize the new IStorage32object.
5008    */
5009   newStorage = HeapAlloc(GetProcessHeap(), 0, sizeof(Storage32Impl));
5010
5011   if (newStorage == 0)
5012     return STG_E_INSUFFICIENTMEMORY;
5013
5014   hr = Storage32Impl_Construct(
5015          newStorage,
5016          hFile,
5017          grfMode);
5018
5019   if (FAILED(hr))
5020     return hr;
5021
5022   /*
5023    * Get an "out" pointer for the caller.
5024    */
5025   hr = Storage32BaseImpl_QueryInterface(
5026          (IStorage32*)newStorage,
5027          (REFIID)&IID_IStorage,
5028          (void**)ppstgOpen);
5029
5030   return hr;
5031 }
5032
5033 /******************************************************************************
5034  *              WriteClassStg32        [OLE32.148]
5035  *
5036  * This method will store the specified CLSID in the specified storage object
5037  */
5038 HRESULT WINAPI WriteClassStg32(IStorage32* pStg, REFCLSID rclsid)
5039 {
5040   HRESULT hRes;
5041
5042   assert(pStg != 0);
5043
5044   hRes = IStorage32_SetClass(pStg, rclsid);
5045
5046   return hRes;
5047 }
5048
5049
5050 /****************************************************************************
5051  * This method validate a STGM parameter that can contain the values below
5052  *
5053  * STGM_DIRECT               0x00000000
5054  * STGM_TRANSACTED           0x00010000
5055  * STGM_SIMPLE               0x08000000
5056  *
5057  * STGM_READ                 0x00000000
5058  * STGM_WRITE                0x00000001
5059  * STGM_READWRITE            0x00000002
5060  *
5061  * STGM_SHARE_DENY_NONE      0x00000040
5062  * STGM_SHARE_DENY_READ      0x00000030
5063  * STGM_SHARE_DENY_WRITE     0x00000020
5064  * STGM_SHARE_EXCLUSIVE      0x00000010
5065  *
5066  * STGM_PRIORITY             0x00040000
5067  * STGM_DELETEONRELEASE      0x04000000
5068  *
5069  * STGM_CREATE               0x00001000
5070  * STGM_CONVERT              0x00020000
5071  * STGM_FAILIFTHERE          0x00000000
5072  *
5073  * STGM_NOSCRATCH            0x00100000
5074  * STGM_NOSNAPSHOT           0x00200000
5075  */
5076 static HRESULT validateSTGM(DWORD stgm)
5077 {
5078   BOOL32 bSTGM_TRANSACTED       = ((stgm & STGM_TRANSACTED) == STGM_TRANSACTED);
5079   BOOL32 bSTGM_SIMPLE           = ((stgm & STGM_SIMPLE) == STGM_SIMPLE);
5080   BOOL32 bSTGM_DIRECT           = ! (bSTGM_TRANSACTED || bSTGM_SIMPLE);
5081
5082   BOOL32 bSTGM_WRITE            = ((stgm & STGM_WRITE) == STGM_WRITE);
5083   BOOL32 bSTGM_READWRITE        = ((stgm & STGM_READWRITE) == STGM_READWRITE);
5084   BOOL32 bSTGM_READ             = ! (bSTGM_WRITE || bSTGM_READWRITE);
5085
5086   BOOL32 bSTGM_SHARE_DENY_NONE  =
5087                      ((stgm & STGM_SHARE_DENY_NONE)  == STGM_SHARE_DENY_NONE);
5088
5089   BOOL32 bSTGM_SHARE_DENY_READ  =
5090                      ((stgm & STGM_SHARE_DENY_READ)  == STGM_SHARE_DENY_READ);
5091
5092   BOOL32 bSTGM_SHARE_DENY_WRITE =
5093                      ((stgm & STGM_SHARE_DENY_WRITE) == STGM_SHARE_DENY_WRITE);
5094
5095   BOOL32 bSTGM_SHARE_EXCLUSIVE  =
5096                      ((stgm & STGM_SHARE_EXCLUSIVE)  == STGM_SHARE_EXCLUSIVE);
5097
5098   BOOL32 bSTGM_CREATE           = ((stgm & STGM_CREATE) == STGM_CREATE);
5099   BOOL32 bSTGM_CONVERT          = ((stgm & STGM_CONVERT) == STGM_CONVERT);
5100
5101   BOOL32 bSTGM_NOSCRATCH        = ((stgm & STGM_NOSCRATCH) == STGM_NOSCRATCH);
5102   BOOL32 bSTGM_NOSNAPSHOT       = ((stgm & STGM_NOSNAPSHOT) == STGM_NOSNAPSHOT);
5103
5104   /*
5105    * STGM_DIRECT | STGM_TRANSACTED | STGM_SIMPLE
5106    */
5107   if ( ! bSTGM_DIRECT )
5108     if( bSTGM_TRANSACTED && bSTGM_SIMPLE )
5109       return E_FAIL;
5110
5111   /*
5112    * STGM_WRITE |  STGM_READWRITE | STGM_READ
5113    */
5114   if ( ! bSTGM_READ )
5115     if( bSTGM_WRITE && bSTGM_READWRITE )
5116       return E_FAIL;
5117
5118   /*
5119    * STGM_SHARE_DENY_NONE | others
5120    * (I assume here that DENY_READ implies DENY_WRITE)
5121    */
5122   if ( bSTGM_SHARE_DENY_NONE )
5123     if ( bSTGM_SHARE_DENY_READ ||
5124          bSTGM_SHARE_DENY_WRITE ||
5125          bSTGM_SHARE_EXCLUSIVE)
5126       return E_FAIL;
5127
5128   /*
5129    * STGM_CREATE | STGM_CONVERT
5130    * if both are false, STGM_FAILIFTHERE is set to TRUE
5131    */
5132   if ( bSTGM_CREATE && bSTGM_CONVERT )
5133     return E_FAIL;
5134
5135   /*
5136    * STGM_NOSCRATCH requires STGM_TRANSACTED
5137    */
5138   if ( bSTGM_NOSCRATCH && ! bSTGM_TRANSACTED )
5139     return E_FAIL;
5140
5141   /*
5142    * STGM_NOSNAPSHOT requires STGM_TRANSACTED and
5143    * not STGM_SHARE_EXCLUSIVE or STGM_SHARE_DENY_WRITE`
5144    */
5145   if (bSTGM_NOSNAPSHOT)
5146   {
5147     if ( ! ( bSTGM_TRANSACTED &&
5148            !(bSTGM_SHARE_EXCLUSIVE || bSTGM_SHARE_DENY_WRITE)) )
5149     return E_FAIL;
5150   }
5151
5152   return S_OK;
5153 }
5154
5155 /****************************************************************************
5156  *      GetShareModeFromSTGM
5157  *
5158  * This method will return a share mode flag from a STGM value.
5159  * The STGM value is assumed valid.
5160  */
5161 static DWORD GetShareModeFromSTGM(DWORD stgm)
5162 {
5163   DWORD dwShareMode = 0;
5164   BOOL32 bSTGM_SHARE_DENY_NONE  =
5165                      ((stgm & STGM_SHARE_DENY_NONE)  == STGM_SHARE_DENY_NONE);
5166
5167   BOOL32 bSTGM_SHARE_DENY_READ  =
5168                      ((stgm & STGM_SHARE_DENY_READ)  == STGM_SHARE_DENY_READ);
5169
5170   BOOL32 bSTGM_SHARE_DENY_WRITE =
5171                      ((stgm & STGM_SHARE_DENY_WRITE) == STGM_SHARE_DENY_WRITE);
5172
5173   BOOL32 bSTGM_SHARE_EXCLUSIVE  =
5174                      ((stgm & STGM_SHARE_EXCLUSIVE)  == STGM_SHARE_EXCLUSIVE);
5175
5176   if ((bSTGM_SHARE_EXCLUSIVE) || (bSTGM_SHARE_DENY_READ))
5177     dwShareMode = 0;
5178
5179   if (bSTGM_SHARE_DENY_NONE)
5180     dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
5181
5182   if (bSTGM_SHARE_DENY_WRITE)
5183     dwShareMode = FILE_SHARE_READ;
5184
5185   return dwShareMode;
5186 }
5187
5188 /****************************************************************************
5189  *      GetAccessModeFromSTGM
5190  *
5191  * This method will return an access mode flag from a STGM value.
5192  * The STGM value is assumed valid.
5193  */
5194 static DWORD GetAccessModeFromSTGM(DWORD stgm)
5195 {
5196   DWORD dwDesiredAccess = 0;
5197   BOOL32 bSTGM_WRITE     = ((stgm & STGM_WRITE) == STGM_WRITE);
5198   BOOL32 bSTGM_READWRITE = ((stgm & STGM_READWRITE) == STGM_READWRITE);
5199   BOOL32 bSTGM_READ      = ! (bSTGM_WRITE || bSTGM_READWRITE);
5200
5201   if (bSTGM_READ)
5202     dwDesiredAccess = GENERIC_READ;
5203
5204   if (bSTGM_WRITE)
5205     dwDesiredAccess |= GENERIC_WRITE;
5206
5207   if (bSTGM_READWRITE)
5208     dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
5209
5210   return dwDesiredAccess;
5211 }
5212
5213 /****************************************************************************
5214  *      GetCreationModeFromSTGM
5215  *
5216  * This method will return a creation mode flag from a STGM value.
5217  * The STGM value is assumed valid.
5218  */
5219 static DWORD GetCreationModeFromSTGM(DWORD stgm)
5220 {
5221   DWORD dwCreationDistribution;
5222   BOOL32 bSTGM_CREATE      = ((stgm & STGM_CREATE) == STGM_CREATE);
5223   BOOL32 bSTGM_CONVERT     = ((stgm & STGM_CONVERT) == STGM_CONVERT);
5224   BOOL32 bSTGM_FAILIFTHERE = ! (bSTGM_CREATE || bSTGM_CONVERT);
5225
5226   if (bSTGM_CREATE)
5227     dwCreationDistribution = CREATE_NEW;
5228   else if (bSTGM_FAILIFTHERE)
5229     dwCreationDistribution = CREATE_NEW;
5230   else if (bSTGM_CONVERT)
5231   {
5232     FIXME(ole, "STGM_CONVERT not implemented!\n");
5233     dwCreationDistribution = CREATE_NEW;
5234   }
5235
5236   return dwCreationDistribution;
5237 }
5238