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

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