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.s.LowPart, pstatstg->cbSize.s.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.s.LowPart  = currentProperty.size.s.LowPart;
 766     renamedProperty.size.s.HighPart = currentProperty.size.s.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.s.LowPart  = 0;
 940   newStreamProperty.size.s.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.s.LowPart  = 0;
1125   newProperty.size.s.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.s.HighPart = 0;
1247     newSize.s.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.s.HighPart = 0;
1876   size.s.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.s.HighPart = 0;
2284     size.s.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.s.HighPart    = 0;
2352     rootProp.size.s.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.s.HighPart = 0;
3129   offsetInPropSet.s.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.s.LowPart);
3207
3208     buffer->size.s.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.s.HighPart = 0;
3228   offsetInPropSet.s.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.s.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.s.LowPart = 0;
3405   offset.s.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.s.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.s.HighPart = 0;
3438   size.s.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.s.LowPart / This->parentStorage->bigBlockSize;
4266   ULONG offsetInBlock     = offset.s.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.s.LowPart / This->parentStorage->bigBlockSize;
4354   ULONG offsetInBlock     = offset.s.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.s.LowPart / This->parentStorage->bigBlockSize;
4450
4451   if ((newSize.s.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.s.LowPart / This->parentStorage->bigBlockSize;
4550
4551   if ((newSize.s.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.s.LowPart == size.s.LowPart)
4624     return TRUE;
4625
4626   if (newSize.s.LowPart < size.s.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.s.LowPart - size.s.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.s.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.s.HighPart = 0;
4685
4686     result.s.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.s.HighPart = 0;
4768   offsetOfBlockInDepot.s.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.s.HighPart = 0;
4807   offsetOfBlockInDepot.s.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.s.HighPart = 0;
4853
4854   /*
4855    * Scan the small block depot for a free block
4856    */
4857   while (nextBlockIndex != BLOCK_UNUSED)
4858   {
4859     offsetOfBlockInDepot.s.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.s.HighPart = 0;
4947         rootProp.size.s.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.s.LowPart <
4974        (blocksRequired * This->parentStorage->bigBlockSize))
4975     {
4976       rootProp.size.s.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.s.LowPart / This->parentStorage->smallBlockSize;
5009
5010   ULONG offsetInBlock = offset.s.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.s.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.s.HighPart  = 0;
5052     offsetInBigBlockFile.s.LowPart   =
5053       blockIndex * This->parentStorage->smallBlockSize;
5054
5055     offsetInBigBlockFile.s.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.s.LowPart / This->parentStorage->smallBlockSize;
5099
5100   ULONG offsetInBlock = offset.s.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.s.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.s.HighPart  = 0;
5143     offsetInBigBlockFile.s.LowPart   =
5144       blockIndex * This->parentStorage->smallBlockSize;
5145
5146     offsetInBigBlockFile.s.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.s.LowPart / This->parentStorage->smallBlockSize;
5188
5189   if ((newSize.s.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.s.LowPart / This->parentStorage->smallBlockSize;
5301
5302   if ((newSize.s.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.s.LowPart == size.s.LowPart)
5377     return TRUE;
5378
5379   if (newSize.s.LowPart < size.s.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 *str, FILETIME *a, FILETIME *b, FILETIME *c )
5807 {
5808   FIXME("(%s, %p, %p, %p),stub!\n", debugstr_w(str), a, b, c);
5809   return S_OK;
5810 }
5811
5812 /******************************************************************************
5813  *              StgIsStorageILockBytes        [OLE32.@]
5814  *
5815  * Determines if the ILockBytes contains a storage object.
5816  */
5817 HRESULT WINAPI StgIsStorageILockBytes(ILockBytes *plkbyt)
5818 {
5819   BYTE sig[8];
5820   ULARGE_INTEGER offset;
5821
5822   offset.s.HighPart = 0;
5823   offset.s.LowPart  = 0;
5824
5825   ILockBytes_ReadAt(plkbyt, offset, sig, sizeof(sig), NULL);
5826
5827   if (memcmp(sig, STORAGE_magic, sizeof(STORAGE_magic)) == 0)
5828     return S_OK;
5829
5830   return S_FALSE;
5831 }
5832
5833 /******************************************************************************
5834  *              WriteClassStg        [OLE32.@]
5835  *
5836  * This method will store the specified CLSID in the specified storage object
5837  */
5838 HRESULT WINAPI WriteClassStg(IStorage* pStg, REFCLSID rclsid)
5839 {
5840   HRESULT hRes;
5841
5842   assert(pStg != 0);
5843
5844   hRes = IStorage_SetClass(pStg, rclsid);
5845
5846   return hRes;
5847 }
5848
5849 /***********************************************************************
5850  *    ReadClassStg (OLE32.@)
5851  *
5852  * This method reads the CLSID previously written to a storage object with the WriteClassStg.
5853  */
5854 HRESULT WINAPI ReadClassStg(IStorage *pstg,CLSID *pclsid){
5855
5856     STATSTG pstatstg;
5857     HRESULT hRes;
5858
5859     TRACE("()\n");
5860
5861     if(pclsid==NULL)
5862         return E_POINTER;
5863    /*
5864     * read a STATSTG structure (contains the clsid) from the storage
5865     */
5866     hRes=IStorage_Stat(pstg,&pstatstg,STATFLAG_DEFAULT);
5867
5868     if(SUCCEEDED(hRes))
5869         *pclsid=pstatstg.clsid;
5870
5871     return hRes;
5872 }
5873
5874 /***********************************************************************
5875  *    OleLoadFromStream (OLE32.@)
5876  *
5877  * This function loads an object from stream
5878  */
5879 HRESULT  WINAPI OleLoadFromStream(IStream *pStm,REFIID iidInterface,void** ppvObj)
5880 {
5881     CLSID       clsid;
5882     HRESULT     res;
5883     LPPERSISTSTREAM     xstm;
5884
5885     TRACE("(%p,%s,%p)\n",pStm,debugstr_guid(iidInterface),ppvObj);
5886
5887     res=ReadClassStm(pStm,&clsid);
5888     if (!SUCCEEDED(res))
5889         return res;
5890     res=CoCreateInstance(&clsid,NULL,CLSCTX_INPROC_SERVER,iidInterface,ppvObj);
5891     if (!SUCCEEDED(res))
5892         return res;
5893     res=IUnknown_QueryInterface((IUnknown*)*ppvObj,&IID_IPersistStream,(LPVOID*)&xstm);
5894     if (!SUCCEEDED(res)) {
5895         IUnknown_Release((IUnknown*)*ppvObj);
5896         return res;
5897     }
5898     res=IPersistStream_Load(xstm,pStm);
5899     IPersistStream_Release(xstm);
5900     /* FIXME: all refcounts ok at this point? I think they should be:
5901      *          pStm    : unchanged
5902      *          ppvObj  : 1
5903      *          xstm    : 0 (released)
5904      */
5905     return res;
5906 }
5907
5908 /***********************************************************************
5909  *    OleSaveToStream (OLE32.@)
5910  *
5911  * This function saves an object with the IPersistStream interface on it
5912  * to the specified stream.
5913  */
5914 HRESULT  WINAPI OleSaveToStream(IPersistStream *pPStm,IStream *pStm)
5915 {
5916
5917     CLSID clsid;
5918     HRESULT res;
5919
5920     TRACE("(%p,%p)\n",pPStm,pStm);
5921
5922     res=IPersistStream_GetClassID(pPStm,&clsid);
5923
5924     if (SUCCEEDED(res)){
5925
5926         res=WriteClassStm(pStm,&clsid);
5927
5928         if (SUCCEEDED(res))
5929
5930             res=IPersistStream_Save(pPStm,pStm,TRUE);
5931     }
5932
5933     TRACE("Finished Save\n");
5934     return res;
5935 }
5936
5937 /****************************************************************************
5938  * This method validate a STGM parameter that can contain the values below
5939  *
5940  * STGM_DIRECT               0x00000000
5941  * STGM_TRANSACTED           0x00010000
5942  * STGM_SIMPLE               0x08000000
5943  *
5944  * STGM_READ                 0x00000000
5945  * STGM_WRITE                0x00000001
5946  * STGM_READWRITE            0x00000002
5947  *
5948  * STGM_SHARE_DENY_NONE      0x00000040
5949  * STGM_SHARE_DENY_READ      0x00000030
5950  * STGM_SHARE_DENY_WRITE     0x00000020
5951  * STGM_SHARE_EXCLUSIVE      0x00000010
5952  *
5953  * STGM_PRIORITY             0x00040000
5954  * STGM_DELETEONRELEASE      0x04000000
5955  *
5956  * STGM_CREATE               0x00001000
5957  * STGM_CONVERT              0x00020000
5958  * STGM_FAILIFTHERE          0x00000000
5959  *
5960  * STGM_NOSCRATCH            0x00100000
5961  * STGM_NOSNAPSHOT           0x00200000
5962  */
5963 static HRESULT validateSTGM(DWORD stgm)
5964 {
5965   BOOL bSTGM_TRANSACTED       = ((stgm & STGM_TRANSACTED) == STGM_TRANSACTED);
5966   BOOL bSTGM_SIMPLE           = ((stgm & STGM_SIMPLE) == STGM_SIMPLE);
5967   BOOL bSTGM_DIRECT           = ! (bSTGM_TRANSACTED || bSTGM_SIMPLE);
5968
5969   BOOL bSTGM_WRITE            = ((stgm & STGM_WRITE) == STGM_WRITE);
5970   BOOL bSTGM_READWRITE        = ((stgm & STGM_READWRITE) == STGM_READWRITE);
5971   BOOL bSTGM_READ             = ! (bSTGM_WRITE || bSTGM_READWRITE);
5972
5973   BOOL bSTGM_SHARE_DENY_NONE  =
5974                      ((stgm & STGM_SHARE_DENY_NONE)  == STGM_SHARE_DENY_NONE);
5975
5976   BOOL bSTGM_SHARE_DENY_READ  =
5977                      ((stgm & STGM_SHARE_DENY_READ)  == STGM_SHARE_DENY_READ);
5978
5979   BOOL bSTGM_SHARE_DENY_WRITE =
5980                      ((stgm & STGM_SHARE_DENY_WRITE) == STGM_SHARE_DENY_WRITE);
5981
5982   BOOL bSTGM_SHARE_EXCLUSIVE  =
5983                      ((stgm & STGM_SHARE_EXCLUSIVE)  == STGM_SHARE_EXCLUSIVE);
5984
5985   BOOL bSTGM_CREATE           = ((stgm & STGM_CREATE) == STGM_CREATE);
5986   BOOL bSTGM_CONVERT          = ((stgm & STGM_CONVERT) == STGM_CONVERT);
5987
5988   BOOL bSTGM_NOSCRATCH        = ((stgm & STGM_NOSCRATCH) == STGM_NOSCRATCH);
5989   BOOL bSTGM_NOSNAPSHOT       = ((stgm & STGM_NOSNAPSHOT) == STGM_NOSNAPSHOT);
5990
5991   /*
5992    * STGM_DIRECT | STGM_TRANSACTED | STGM_SIMPLE
5993    */
5994   if ( ! bSTGM_DIRECT )
5995     if( bSTGM_TRANSACTED && bSTGM_SIMPLE )
5996       return E_FAIL;
5997
5998   /*
5999    * STGM_WRITE |  STGM_READWRITE | STGM_READ
6000    */
6001   if ( ! bSTGM_READ )
6002     if( bSTGM_WRITE && bSTGM_READWRITE )
6003       return E_FAIL;
6004
6005   /*
6006    * STGM_SHARE_DENY_NONE | others
6007    * (I assume here that DENY_READ implies DENY_WRITE)
6008    */
6009   if ( bSTGM_SHARE_DENY_NONE )
6010     if ( bSTGM_SHARE_DENY_READ ||
6011          bSTGM_SHARE_DENY_WRITE ||
6012          bSTGM_SHARE_EXCLUSIVE)
6013       return E_FAIL;
6014
6015   /*
6016    * STGM_CREATE | STGM_CONVERT
6017    * if both are false, STGM_FAILIFTHERE is set to TRUE
6018    */
6019   if ( bSTGM_CREATE && bSTGM_CONVERT )
6020     return E_FAIL;
6021
6022   /*
6023    * STGM_NOSCRATCH requires STGM_TRANSACTED
6024    */
6025   if ( bSTGM_NOSCRATCH && ! bSTGM_TRANSACTED )
6026     return E_FAIL;
6027
6028   /*
6029    * STGM_NOSNAPSHOT requires STGM_TRANSACTED and
6030    * not STGM_SHARE_EXCLUSIVE or STGM_SHARE_DENY_WRITE`
6031    */
6032   if (bSTGM_NOSNAPSHOT)
6033   {
6034     if ( ! ( bSTGM_TRANSACTED &&
6035            !(bSTGM_SHARE_EXCLUSIVE || bSTGM_SHARE_DENY_WRITE)) )
6036     return E_FAIL;
6037   }
6038
6039   return S_OK;
6040 }
6041
6042 /****************************************************************************
6043  *      GetShareModeFromSTGM
6044  *
6045  * This method will return a share mode flag from a STGM value.
6046  * The STGM value is assumed valid.
6047  */
6048 static DWORD GetShareModeFromSTGM(DWORD stgm)
6049 {
6050   DWORD dwShareMode = 0;
6051   BOOL bSTGM_SHARE_DENY_NONE  =
6052                      ((stgm & STGM_SHARE_DENY_NONE)  == STGM_SHARE_DENY_NONE);
6053
6054   BOOL bSTGM_SHARE_DENY_READ  =
6055                      ((stgm & STGM_SHARE_DENY_READ)  == STGM_SHARE_DENY_READ);
6056
6057   BOOL bSTGM_SHARE_DENY_WRITE =
6058                      ((stgm & STGM_SHARE_DENY_WRITE) == STGM_SHARE_DENY_WRITE);
6059
6060   BOOL bSTGM_SHARE_EXCLUSIVE  =
6061                      ((stgm & STGM_SHARE_EXCLUSIVE)  == STGM_SHARE_EXCLUSIVE);
6062
6063   if ((bSTGM_SHARE_EXCLUSIVE) || (bSTGM_SHARE_DENY_READ))
6064     dwShareMode = 0;
6065
6066   if (bSTGM_SHARE_DENY_NONE)
6067     dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
6068
6069   if (bSTGM_SHARE_DENY_WRITE)
6070     dwShareMode = FILE_SHARE_READ;
6071
6072   return dwShareMode;
6073 }
6074
6075 /****************************************************************************
6076  *      GetAccessModeFromSTGM
6077  *
6078  * This method will return an access mode flag from a STGM value.
6079  * The STGM value is assumed valid.
6080  */
6081 static DWORD GetAccessModeFromSTGM(DWORD stgm)
6082 {
6083   DWORD dwDesiredAccess = GENERIC_READ;
6084   BOOL bSTGM_WRITE     = ((stgm & STGM_WRITE) == STGM_WRITE);
6085   BOOL bSTGM_READWRITE = ((stgm & STGM_READWRITE) == STGM_READWRITE);
6086   BOOL bSTGM_READ      = ! (bSTGM_WRITE || bSTGM_READWRITE);
6087
6088   if (bSTGM_READ)
6089     dwDesiredAccess = GENERIC_READ;
6090
6091   if (bSTGM_WRITE)
6092     dwDesiredAccess |= GENERIC_WRITE;
6093
6094   if (bSTGM_READWRITE)
6095     dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
6096
6097   return dwDesiredAccess;
6098 }
6099
6100 /****************************************************************************
6101  *      GetCreationModeFromSTGM
6102  *
6103  * This method will return a creation mode flag from a STGM value.
6104  * The STGM value is assumed valid.
6105  */
6106 static DWORD GetCreationModeFromSTGM(DWORD stgm)
6107 {
6108   if ( stgm & STGM_CREATE)
6109     return CREATE_ALWAYS;
6110   if (stgm & STGM_CONVERT) {
6111     FIXME("STGM_CONVERT not implemented!\n");
6112     return CREATE_NEW;
6113   }
6114   /* All other cases */
6115   if (stgm & ~ (STGM_CREATE|STGM_CONVERT))
6116         FIXME("unhandled storage mode : 0x%08lx\n",stgm & ~ (STGM_CREATE|STGM_CONVERT));
6117   return CREATE_NEW;
6118 }
6119
6120
6121 /*************************************************************************
6122  * OLECONVERT_LoadOLE10 [Internal]
6123  *
6124  * Loads the OLE10 STREAM to memory
6125  *
6126  * PARAMS
6127  *     pOleStream   [I] The OLESTREAM
6128  *     pData        [I] Data Structure for the OLESTREAM Data
6129  *
6130  * RETURNS
6131  *     Success:  S_OK
6132  *     Failure:  CONVERT10_E_OLESTREAM_GET for invalid Get
6133  *               CONVERT10_E_OLESTREAM_FMT if the OLEID is invalide
6134  *
6135  * NOTES
6136  *     This function is used by OleConvertOLESTREAMToIStorage only.
6137  *
6138  *     Memory allocated for pData must be freed by the caller
6139  */
6140 HRESULT OLECONVERT_LoadOLE10(LPOLESTREAM pOleStream, OLECONVERT_OLESTREAM_DATA *pData, BOOL bStrem1)
6141 {
6142         DWORD dwSize;
6143         HRESULT hRes = S_OK;
6144         int nTryCnt=0;
6145         int max_try = 6;
6146
6147         pData->pData = NULL;
6148         pData->pstrOleObjFileName = (CHAR *) NULL;
6149
6150         for( nTryCnt=0;nTryCnt < max_try; nTryCnt++)
6151         {
6152         /* Get the OleID */
6153         dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)&(pData->dwOleID), sizeof(pData->dwOleID));
6154         if(dwSize != sizeof(pData->dwOleID))
6155         {
6156                 hRes = CONVERT10_E_OLESTREAM_GET;
6157         }
6158         else if(pData->dwOleID != OLESTREAM_ID)
6159         {
6160                 hRes = CONVERT10_E_OLESTREAM_FMT;
6161         }
6162                 else
6163                 {
6164                         hRes = S_OK;
6165                         break;
6166                 }
6167         }
6168
6169         if(hRes == S_OK)
6170         {
6171                 /* Get the TypeID...more info needed for this field */
6172                 dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)&(pData->dwTypeID), sizeof(pData->dwTypeID));
6173                 if(dwSize != sizeof(pData->dwTypeID))
6174                 {
6175                         hRes = CONVERT10_E_OLESTREAM_GET;
6176                 }
6177         }
6178         if(hRes == S_OK)
6179         {
6180                 if(pData->dwTypeID != 0)
6181                 {
6182                         /* Get the length of the OleTypeName */
6183                         dwSize = pOleStream->lpstbl->Get(pOleStream, (void *) &(pData->dwOleTypeNameLength), sizeof(pData->dwOleTypeNameLength));
6184                         if(dwSize != sizeof(pData->dwOleTypeNameLength))
6185                         {
6186                                 hRes = CONVERT10_E_OLESTREAM_GET;
6187                         }
6188
6189                         if(hRes == S_OK)
6190                         {
6191                                 if(pData->dwOleTypeNameLength > 0)
6192                                 {
6193                                         /* Get the OleTypeName */
6194                                         dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)pData->strOleTypeName, pData->dwOleTypeNameLength);
6195                                         if(dwSize != pData->dwOleTypeNameLength)
6196                                         {
6197                                                 hRes = CONVERT10_E_OLESTREAM_GET;
6198                                         }
6199                                 }
6200                         }
6201                         if(bStrem1)
6202                         {
6203                                 dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)&(pData->dwOleObjFileNameLength), sizeof(pData->dwOleObjFileNameLength));
6204                                 if(dwSize != sizeof(pData->dwOleObjFileNameLength))
6205                                 {
6206                                         hRes = CONVERT10_E_OLESTREAM_GET;
6207                                 }
6208                         if(hRes == S_OK)
6209                         {
6210                                         if(pData->dwOleObjFileNameLength < 1) /* there is no file name exist */
6211                                                 pData->dwOleObjFileNameLength = sizeof(pData->dwOleObjFileNameLength);
6212                                         pData->pstrOleObjFileName = (CHAR *)HeapAlloc(GetProcessHeap(), 0, pData->dwOleObjFileNameLength);
6213                                         if(pData->pstrOleObjFileName)
6214                                         {
6215                                                 dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)(pData->pstrOleObjFileName),pData->dwOleObjFileNameLength);
6216                                                 if(dwSize != pData->dwOleObjFileNameLength)
6217                                                 {
6218                                                         hRes = CONVERT10_E_OLESTREAM_GET;
6219                                                 }
6220                                         }
6221                                         else
6222                                                 hRes = CONVERT10_E_OLESTREAM_GET;
6223                                 }
6224                         }
6225                         else
6226                         {
6227                                 /* Get the Width of the Metafile */
6228                                 dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)&(pData->dwMetaFileWidth), sizeof(pData->dwMetaFileWidth));
6229                                 if(dwSize != sizeof(pData->dwMetaFileWidth))
6230                                 {
6231                                         hRes = CONVERT10_E_OLESTREAM_GET;
6232                                 }
6233                         if(hRes == S_OK)
6234                         {
6235                                 /* Get the Height of the Metafile */
6236                                 dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)&(pData->dwMetaFileHeight), sizeof(pData->dwMetaFileHeight));
6237                                 if(dwSize != sizeof(pData->dwMetaFileHeight))
6238                                 {
6239                                         hRes = CONVERT10_E_OLESTREAM_GET;
6240                                 }
6241                         }
6242                         }
6243                         if(hRes == S_OK)
6244                         {
6245                                 /* Get the Length of the Data */
6246                                 dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)&(pData->dwDataLength), sizeof(pData->dwDataLength));
6247                                 if(dwSize != sizeof(pData->dwDataLength))
6248                                 {
6249                                         hRes = CONVERT10_E_OLESTREAM_GET;
6250                                 }
6251                         }
6252
6253                         if(hRes == S_OK) /* I don't know what is this 8 byts information is we have to figure out */
6254                         {
6255                                 if(!bStrem1) /* if it is a second OLE stream data */
6256                                 {
6257                                         pData->dwDataLength -= 8;
6258                                         dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)(pData->strUnknown), sizeof(pData->strUnknown));
6259                                         if(dwSize != sizeof(pData->strUnknown))
6260                                         {
6261                                                 hRes = CONVERT10_E_OLESTREAM_GET;
6262                                         }
6263                                 }
6264                         }
6265                         if(hRes == S_OK)
6266                         {
6267                                 if(pData->dwDataLength > 0)
6268                                 {
6269                                         pData->pData = (BYTE *)HeapAlloc(GetProcessHeap(),0,pData->dwDataLength);
6270
6271                                         /* Get Data (ex. IStorage, Metafile, or BMP) */
6272                                         if(pData->pData)
6273                                         {
6274                                                 dwSize = pOleStream->lpstbl->Get(pOleStream, (void *)pData->pData, pData->dwDataLength);
6275                                                 if(dwSize != pData->dwDataLength)
6276                                                 {
6277                                                         hRes = CONVERT10_E_OLESTREAM_GET;
6278                                                 }
6279                                         }
6280                                         else
6281                                         {
6282                                                 hRes = CONVERT10_E_OLESTREAM_GET;
6283                                         }
6284                                 }
6285                         }
6286                 }
6287         }
6288         return hRes;
6289 }
6290
6291 /*************************************************************************
6292  * OLECONVERT_SaveOLE10 [Internal]
6293  *
6294  * Saves the OLE10 STREAM From memory
6295  *
6296  * PARAMS
6297  *     pData        [I] Data Structure for the OLESTREAM Data
6298  *     pOleStream   [I] The OLESTREAM to save
6299  *
6300  * RETURNS
6301  *     Success:  S_OK
6302  *     Failure:  CONVERT10_E_OLESTREAM_PUT for invalid Put
6303  *
6304  * NOTES
6305  *     This function is used by OleConvertIStorageToOLESTREAM only.
6306  *
6307  */
6308 HRESULT OLECONVERT_SaveOLE10(OLECONVERT_OLESTREAM_DATA *pData, LPOLESTREAM pOleStream)
6309 {
6310     DWORD dwSize;
6311     HRESULT hRes = S_OK;
6312
6313
6314    /* Set the OleID */
6315     dwSize = pOleStream->lpstbl->Put(pOleStream, (void *)&(pData->dwOleID), sizeof(pData->dwOleID));
6316     if(dwSize != sizeof(pData->dwOleID))
6317     {
6318         hRes = CONVERT10_E_OLESTREAM_PUT;
6319     }
6320
6321     if(hRes == S_OK)
6322     {
6323         /* Set the TypeID */
6324         dwSize = pOleStream->lpstbl->Put(pOleStream, (void *)&(pData->dwTypeID), sizeof(pData->dwTypeID));
6325         if(dwSize != sizeof(pData->dwTypeID))
6326         {
6327             hRes = CONVERT10_E_OLESTREAM_PUT;
6328         }
6329     }
6330
6331     if(pData->dwOleID == OLESTREAM_ID && pData->dwTypeID != 0 && hRes == S_OK)
6332     {
6333         /* Set the Length of the OleTypeName */
6334         dwSize = pOleStream->lpstbl->Put(pOleStream, (void *)&(pData->dwOleTypeNameLength), sizeof(pData->dwOleTypeNameLength));
6335         if(dwSize != sizeof(pData->dwOleTypeNameLength))
6336         {
6337             hRes = CONVERT10_E_OLESTREAM_PUT;
6338         }
6339
6340         if(hRes == S_OK)
6341         {
6342             if(pData->dwOleTypeNameLength > 0)
6343             {
6344                 /* Set the OleTypeName */
6345                 dwSize = pOleStream->lpstbl->Put(pOleStream, (void *)  pData->strOleTypeName, pData->dwOleTypeNameLength);
6346                 if(dwSize != pData->dwOleTypeNameLength)
6347                 {
6348                     hRes = CONVERT10_E_OLESTREAM_PUT;
6349                 }
6350             }
6351         }
6352
6353         if(hRes == S_OK)
6354         {
6355             /* Set the width of the Metafile */
6356             dwSize = pOleStream->lpstbl->Put(pOleStream, (void *)&(pData->dwMetaFileWidth), sizeof(pData->dwMetaFileWidth));
6357             if(dwSize != sizeof(pData->dwMetaFileWidth))
6358             {
6359                 hRes = CONVERT10_E_OLESTREAM_PUT;
6360             }
6361         }
6362
6363         if(hRes == S_OK)
6364         {
6365             /* Set the height of the Metafile */
6366             dwSize = pOleStream->lpstbl->Put(pOleStream, (void *)&(pData->dwMetaFileHeight), sizeof(pData->dwMetaFileHeight));
6367             if(dwSize != sizeof(pData->dwMetaFileHeight))
6368             {
6369                 hRes = CONVERT10_E_OLESTREAM_PUT;
6370             }
6371         }
6372
6373         if(hRes == S_OK)
6374         {
6375             /* Set the length of the Data */
6376             dwSize = pOleStream->lpstbl->Put(pOleStream, (void *)&(pData->dwDataLength), sizeof(pData->dwDataLength));
6377             if(dwSize != sizeof(pData->dwDataLength))
6378             {
6379                 hRes = CONVERT10_E_OLESTREAM_PUT;
6380             }
6381         }
6382
6383         if(hRes == S_OK)
6384         {
6385             if(pData->dwDataLength > 0)
6386             {
6387                 /* Set the Data (eg. IStorage, Metafile, Bitmap) */
6388                 dwSize = pOleStream->lpstbl->Put(pOleStream, (void *)  pData->pData, pData->dwDataLength);
6389                 if(dwSize != pData->dwDataLength)
6390                 {
6391                     hRes = CONVERT10_E_OLESTREAM_PUT;
6392                 }
6393             }
6394         }
6395     }
6396     return hRes;
6397 }
6398
6399 /*************************************************************************
6400  * OLECONVERT_GetOLE20FromOLE10[Internal]
6401  *
6402  * This function copies OLE10 Data (the IStorage in the OLESTREAM) to disk,
6403  * opens it, and copies the content to the dest IStorage for
6404  * OleConvertOLESTREAMToIStorage
6405  *
6406  *
6407  * PARAMS
6408  *     pDestStorage  [I] The IStorage to copy the data to
6409  *     pBuffer       [I] Buffer that contains the IStorage from the OLESTREAM
6410  *     nBufferLength [I] The size of the buffer
6411  *
6412  * RETURNS
6413  *     Nothing
6414  *
6415  * NOTES
6416  *
6417  *
6418  */
6419 void OLECONVERT_GetOLE20FromOLE10(LPSTORAGE pDestStorage, BYTE *pBuffer, DWORD nBufferLength)
6420 {
6421     HRESULT hRes;
6422     HANDLE hFile;
6423     IStorage *pTempStorage;
6424     DWORD dwNumOfBytesWritten;
6425     WCHAR wstrTempDir[MAX_PATH], wstrTempFile[MAX_PATH];
6426     WCHAR wstrPrefix[] = {'s', 'i', 's', 0};
6427
6428     /* Create a temp File */
6429     GetTempPathW(MAX_PATH, wstrTempDir);
6430     GetTempFileNameW(wstrTempDir, wstrPrefix, 0, wstrTempFile);
6431     hFile = CreateFileW(wstrTempFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
6432
6433     if(hFile != INVALID_HANDLE_VALUE)
6434     {
6435         /* Write IStorage Data to File */
6436         WriteFile(hFile, pBuffer, nBufferLength, &dwNumOfBytesWritten, NULL);
6437         CloseHandle(hFile);
6438
6439         /* Open and copy temp storage to the Dest Storage */
6440         hRes = StgOpenStorage(wstrTempFile, NULL, STGM_READ, NULL, 0, &pTempStorage);
6441         if(hRes == S_OK)
6442         {
6443             hRes = StorageImpl_CopyTo(pTempStorage, 0, NULL, NULL, pDestStorage);
6444             StorageBaseImpl_Release(pTempStorage);
6445         }
6446         DeleteFileW(wstrTempFile);
6447     }
6448 }
6449
6450
6451 /*************************************************************************
6452  * OLECONVERT_WriteOLE20ToBuffer [Internal]
6453  *
6454  * Saves the OLE10 STREAM From memory
6455  *
6456  * PARAMS
6457  *     pStorage  [I] The Src IStorage to copy
6458  *     pData     [I] The Dest Memory to write to.
6459  *
6460  * RETURNS
6461  *     The size in bytes allocated for pData
6462  *
6463  * NOTES
6464  *     Memory allocated for pData must be freed by the caller
6465  *
6466  *     Used by OleConvertIStorageToOLESTREAM only.
6467  *
6468  */
6469 DWORD OLECONVERT_WriteOLE20ToBuffer(LPSTORAGE pStorage, BYTE **pData)
6470 {
6471     HANDLE hFile;
6472     HRESULT hRes;
6473     DWORD nDataLength = 0;
6474     IStorage *pTempStorage;
6475     WCHAR wstrTempDir[MAX_PATH], wstrTempFile[MAX_PATH];
6476     WCHAR wstrPrefix[] = {'s', 'i', 's', 0};
6477
6478     *pData = NULL;
6479
6480     /* Create temp Storage */
6481     GetTempPathW(MAX_PATH, wstrTempDir);
6482     GetTempFileNameW(wstrTempDir, wstrPrefix, 0, wstrTempFile);
6483     hRes = StgCreateDocfile(wstrTempFile, STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &pTempStorage);
6484
6485     if(hRes == S_OK)
6486     {
6487         /* Copy Src Storage to the Temp Storage */
6488         StorageImpl_CopyTo(pStorage, 0, NULL, NULL, pTempStorage);
6489         StorageBaseImpl_Release(pTempStorage);
6490
6491         /* Open Temp Storage as a file and copy to memory */
6492         hFile = CreateFileW(wstrTempFile, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
6493         if(hFile != INVALID_HANDLE_VALUE)
6494         {
6495             nDataLength = GetFileSize(hFile, NULL);
6496             *pData = (BYTE *) HeapAlloc(GetProcessHeap(),0,nDataLength);
6497             ReadFile(hFile, *pData, nDataLength, &nDataLength, 0);
6498             CloseHandle(hFile);
6499         }
6500         DeleteFileW(wstrTempFile);
6501     }
6502     return nDataLength;
6503 }
6504
6505 /*************************************************************************
6506  * OLECONVERT_CreateOleStream [Internal]
6507  *
6508  * Creates the "\001OLE" stream in the IStorage if necessary.
6509  *
6510  * PARAMS
6511  *     pStorage     [I] Dest storage to create the stream in
6512  *
6513  * RETURNS
6514  *     Nothing
6515  *
6516  * NOTES
6517  *     This function is used by OleConvertOLESTREAMToIStorage only.
6518  *
6519  *     This stream is still unknown, MS Word seems to have extra data
6520  *     but since the data is stored in the OLESTREAM there should be
6521  *     no need to recreate the stream.  If the stream is manually
6522  *     deleted it will create it with this default data.
6523  *
6524  */
6525 void OLECONVERT_CreateOleStream(LPSTORAGE pStorage)
6526 {
6527     HRESULT hRes;
6528     IStream *pStream;
6529     WCHAR wstrStreamName[] = {1,'O', 'l', 'e', 0};
6530     BYTE pOleStreamHeader [] =
6531     {
6532         0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
6533         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6534         0x00, 0x00, 0x00, 0x00
6535     };
6536
6537     /* Create stream if not present */
6538     hRes = IStorage_CreateStream(pStorage, wstrStreamName,
6539         STGM_WRITE  | STGM_SHARE_EXCLUSIVE, 0, 0, &pStream );
6540
6541     if(hRes == S_OK)
6542     {
6543         /* Write default Data */
6544         hRes = IStream_Write(pStream, pOleStreamHeader, sizeof(pOleStreamHeader), NULL);
6545         IStream_Release(pStream);
6546     }
6547 }
6548
6549 /* write a string to a stream, preceded by its length */
6550 static HRESULT STREAM_WriteString( IStream *stm, LPCWSTR string )
6551 {
6552     HRESULT r;
6553     LPSTR str;
6554     DWORD len = 0;
6555
6556     if( string )
6557         len = WideCharToMultiByte( CP_ACP, 0, string, -1, NULL, 0, NULL, NULL);
6558     r = IStream_Write( stm, &len, sizeof(len), NULL);
6559     if( FAILED( r ) )
6560         return r;
6561     if(len == 0)
6562         return r;
6563     str = CoTaskMemAlloc( len );
6564     WideCharToMultiByte( CP_ACP, 0, string, -1, str, len, NULL, NULL);
6565     r = IStream_Write( stm, str, len, NULL);
6566     CoTaskMemFree( str );
6567     return r;
6568 }
6569
6570 /* read a string preceded by its length from a stream */
6571 static HRESULT STREAM_ReadString( IStream *stm, LPWSTR *string )
6572 {
6573     HRESULT r;
6574     DWORD len, count = 0;
6575     LPSTR str;
6576     LPWSTR wstr;
6577
6578     r = IStream_Read( stm, &len, sizeof(len), &count );
6579     if( FAILED( r ) )
6580         return r;
6581     if( count != sizeof(len) )
6582         return E_OUTOFMEMORY;
6583
6584     TRACE("%ld bytes\n",len);
6585
6586     str = CoTaskMemAlloc( len );
6587     if( !str )
6588         return E_OUTOFMEMORY;
6589     count = 0;
6590     r = IStream_Read( stm, str, len, &count );
6591     if( FAILED( r ) )
6592         return r;
6593     if( count != len )
6594     {
6595         CoTaskMemFree( str );
6596         return E_OUTOFMEMORY;
6597     }
6598
6599     TRACE("Read string %s\n",debugstr_an(str,len));
6600
6601     len = MultiByteToWideChar( CP_ACP, 0, str, count, NULL, 0 );
6602     wstr = CoTaskMemAlloc( (len + 1)*sizeof (WCHAR) );
6603     if( wstr )
6604          MultiByteToWideChar( CP_ACP, 0, str, count, wstr, len );
6605     CoTaskMemFree( str );
6606
6607     *string = wstr;
6608
6609     return r;
6610 }
6611
6612
6613 static HRESULT STORAGE_WriteCompObj( LPSTORAGE pstg, CLSID *clsid,
6614     LPCWSTR lpszUserType, LPCWSTR szClipName, LPCWSTR szProgIDName )
6615 {
6616     IStream *pstm;
6617     HRESULT r = S_OK;
6618     WCHAR szwStreamName[] = {1, 'C', 'o', 'm', 'p', 'O', 'b', 'j', 0};
6619
6620     static const BYTE unknown1[12] =
6621        { 0x01, 0x00, 0xFE, 0xFF, 0x03, 0x0A, 0x00, 0x00,
6622          0xFF, 0xFF, 0xFF, 0xFF};
6623     static const BYTE unknown2[16] =
6624        { 0xF4, 0x39, 0xB2, 0x71, 0x00, 0x00, 0x00, 0x00,
6625          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
6626
6627     TRACE("%p %s %s %s %s\n", pstg, debugstr_guid(clsid),
6628            debugstr_w(lpszUserType), debugstr_w(szClipName),
6629            debugstr_w(szProgIDName));
6630
6631     /*  Create a CompObj stream if it doesn't exist */
6632     r = IStorage_CreateStream(pstg, szwStreamName,
6633         STGM_WRITE  | STGM_SHARE_EXCLUSIVE, 0, 0, &pstm );
6634     if( FAILED (r) )
6635         return r;
6636
6637     /* Write CompObj Structure to stream */
6638     r = IStream_Write(pstm, unknown1, sizeof(unknown1), NULL);
6639
6640     if( SUCCEEDED( r ) )
6641         r = WriteClassStm( pstm, clsid );
6642
6643     if( SUCCEEDED( r ) )
6644         r = STREAM_WriteString( pstm, lpszUserType );
6645     if( SUCCEEDED( r ) )
6646         r = STREAM_WriteString( pstm, szClipName );
6647     if( SUCCEEDED( r ) )
6648         r = STREAM_WriteString( pstm, szProgIDName );
6649     if( SUCCEEDED( r ) )
6650         r = IStream_Write(pstm, unknown2, sizeof(unknown2), NULL);
6651
6652     IStream_Release( pstm );
6653
6654     return r;
6655 }
6656
6657 /* enumerate HKEY_CLASSES_ROOT\\CLSID looking for a CLSID whose name matches */
6658 static HRESULT CLSIDFromUserType(LPCWSTR lpszUserType, CLSID *clsid)
6659 {
6660     LONG r, count, i, len;
6661     WCHAR szKey[0x40];
6662     HKEY hkey, hkeyclsid;
6663     LPWSTR buffer = NULL;
6664     BOOL found = FALSE;
6665     const WCHAR szclsid[] = { 'C','L','S','I','D',0 };
6666
6667     TRACE("Finding CLSID for %s\n", debugstr_w(lpszUserType));
6668
6669     r = RegOpenKeyW( HKEY_CLASSES_ROOT, szclsid, &hkeyclsid );
6670     if( r )
6671         return E_INVALIDARG;
6672
6673     len = lstrlenW( lpszUserType ) + 1;
6674     buffer = CoTaskMemAlloc( len * sizeof (WCHAR) );
6675     if( !buffer )
6676         goto end;
6677
6678     for(i=0; !found; i++ )
6679     {
6680         r = RegEnumKeyW( hkeyclsid, i, szKey, sizeof(szKey)/sizeof(WCHAR));
6681         if( r != ERROR_SUCCESS )
6682             break;
6683         hkey = 0;
6684         r = RegOpenKeyW( hkeyclsid, szKey, &hkey );
6685         if( r != ERROR_SUCCESS )
6686             break;
6687         count = len * sizeof (WCHAR);
6688         r = RegQueryValueW( hkey, NULL, buffer, &count );
6689         found = ( r == ERROR_SUCCESS ) &&
6690                 ( count == len*sizeof(WCHAR) ) &&
6691                 !lstrcmpW( buffer, lpszUserType ) ;
6692         RegCloseKey( hkey );
6693     }
6694
6695 end:
6696     if( buffer )
6697         CoTaskMemFree( buffer );
6698     RegCloseKey( hkeyclsid );
6699
6700     if ( !found )
6701         return E_INVALIDARG;
6702
6703     TRACE("clsid is %s\n", debugstr_w( szKey ) );
6704
6705     r = CLSIDFromString( szKey, clsid );
6706
6707     return r;
6708 }
6709
6710
6711 /***********************************************************************
6712  *               WriteFmtUserTypeStg (OLE32.@)
6713  */
6714 HRESULT WINAPI WriteFmtUserTypeStg(
6715           LPSTORAGE pstg, CLIPFORMAT cf, LPOLESTR lpszUserType)
6716 {
6717     HRESULT r;
6718     WCHAR szwClipName[0x40];
6719     WCHAR szCLSIDName[OLESTREAM_MAX_STR_LEN];
6720     CLSID clsid;
6721     LPWSTR wstrProgID;
6722     DWORD n;
6723     LPMALLOC allocator = NULL;
6724
6725     TRACE("(%p,%x,%s)\n",pstg,cf,debugstr_w(lpszUserType));
6726
6727     r = CoGetMalloc(0, &allocator);
6728     if( FAILED( r) )
6729         return E_OUTOFMEMORY;
6730
6731     /* get the clipboard format name */
6732     n = GetClipboardFormatNameW( cf, szwClipName, sizeof(szwClipName) );
6733     szwClipName[n]=0;
6734
6735     TRACE("Clipboard name is %s\n", debugstr_w(szwClipName));
6736
6737     /* Get the CLSID */
6738     szCLSIDName[0]=0;
6739     r = CLSIDFromUserType(lpszUserType, &clsid);
6740     if( FAILED( r ) )
6741         return r;
6742
6743     TRACE("CLSID is %s\n",debugstr_guid(&clsid));
6744
6745     /* get the real program ID */
6746     r = ProgIDFromCLSID( &clsid, &wstrProgID);
6747     if( FAILED( r ) )
6748         return r;
6749
6750     TRACE("progid is %s\n",debugstr_w(wstrProgID));
6751
6752     /* if we have a good string, write the stream */
6753     if( wstrProgID )
6754         r = STORAGE_WriteCompObj( pstg, &clsid,
6755                 lpszUserType, szwClipName, wstrProgID );
6756     else
6757         r = E_OUTOFMEMORY;
6758
6759     IMalloc_Free( allocator, wstrProgID);
6760
6761     return r;
6762 }
6763
6764
6765 /******************************************************************************
6766  *              ReadFmtUserTypeStg        [OLE32.@]
6767  */
6768 HRESULT WINAPI ReadFmtUserTypeStg (LPSTORAGE pstg, CLIPFORMAT* pcf, LPOLESTR* lplpszUserType)
6769 {
6770     HRESULT r;
6771     IStream *stm = 0;
6772     const WCHAR szCompObj[] = { 1, 'C','o','m','p','O','b','j', 0 };
6773     unsigned char unknown1[12];
6774     unsigned char unknown2[16];
6775     DWORD count;
6776     LPWSTR szProgIDName = NULL, szCLSIDName = NULL, szOleTypeName = NULL;
6777     CLSID clsid;
6778
6779     TRACE("(%p,%p,%p)\n", pstg, pcf, lplpszUserType);
6780
6781     r = IStorage_OpenStream( pstg, szCompObj, NULL,
6782                     STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm );
6783     if( FAILED ( r ) )
6784     {
6785         ERR("Failed to open stream\n");
6786         return r;
6787     }
6788
6789     /* read the various parts of the structure */
6790     r = IStream_Read( stm, unknown1, sizeof(unknown1), &count );
6791     if( FAILED( r ) || ( count != sizeof(unknown1) ) )
6792         goto end;
6793     r = ReadClassStm( stm, &clsid );
6794     if( FAILED( r ) )
6795         goto end;
6796
6797     r = STREAM_ReadString( stm, &szCLSIDName );
6798     if( FAILED( r ) )
6799         goto end;
6800
6801     r = STREAM_ReadString( stm, &szOleTypeName );
6802     if( FAILED( r ) )
6803         goto end;
6804
6805     r = STREAM_ReadString( stm, &szProgIDName );
6806     if( FAILED( r ) )
6807         goto end;
6808
6809     r = IStream_Read( stm, unknown2, sizeof(unknown2), &count );
6810     if( FAILED( r ) || ( count != sizeof(unknown2) ) )
6811         goto end;
6812
6813     /* ok, success... now we just need to store what we found */
6814     if( pcf )
6815         *pcf = RegisterClipboardFormatW( szOleTypeName );
6816     CoTaskMemFree( szOleTypeName );
6817
6818     if( lplpszUserType )
6819         *lplpszUserType = szCLSIDName;
6820     CoTaskMemFree( szProgIDName );
6821
6822 end:
6823     IStream_Release( stm );
6824
6825     return r;
6826 }
6827
6828
6829 /*************************************************************************
6830  * OLECONVERT_CreateCompObjStream [Internal]
6831  *
6832  * Creates a "\001CompObj" is the destination IStorage if necessary.
6833  *
6834  * PARAMS
6835  *     pStorage       [I] The dest IStorage to create the CompObj Stream
6836  *                        if necessary.
6837  *     strOleTypeName [I] The ProgID
6838  *
6839  * RETURNS
6840  *     Success:  S_OK
6841  *     Failure:  REGDB_E_CLASSNOTREG if cannot reconstruct the stream
6842  *
6843  * NOTES
6844  *     This function is used by OleConvertOLESTREAMToIStorage only.
6845  *
6846  *     The stream data is stored in the OLESTREAM and there should be
6847  *     no need to recreate the stream.  If the stream is manually
6848  *     deleted it will attempt to create it by querying the registry.
6849  *
6850  *
6851  */
6852 HRESULT OLECONVERT_CreateCompObjStream(LPSTORAGE pStorage, LPCSTR strOleTypeName)
6853 {
6854     IStream *pStream;
6855     HRESULT hStorageRes, hRes = S_OK;
6856     OLECONVERT_ISTORAGE_COMPOBJ IStorageCompObj;
6857     WCHAR wstrStreamName[] = {1,'C', 'o', 'm', 'p', 'O', 'b', 'j', 0};
6858
6859     BYTE pCompObjUnknown1[] = {0x01, 0x00, 0xFE, 0xFF, 0x03, 0x0A, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF};
6860     BYTE pCompObjUnknown2[] = {0xF4, 0x39, 0xB2, 0x71};
6861
6862     /* Initialize the CompObj structure */
6863     memset(&IStorageCompObj, 0, sizeof(IStorageCompObj));
6864     memcpy(&(IStorageCompObj.byUnknown1), pCompObjUnknown1, sizeof(pCompObjUnknown1));
6865     memcpy(&(IStorageCompObj.byUnknown2), pCompObjUnknown2, sizeof(pCompObjUnknown2));
6866
6867
6868     /*  Create a CompObj stream if it doesn't exist */
6869     hStorageRes = IStorage_CreateStream(pStorage, wstrStreamName,
6870         STGM_WRITE  | STGM_SHARE_EXCLUSIVE, 0, 0, &pStream );
6871     if(hStorageRes == S_OK)
6872     {
6873         /* copy the OleTypeName to the compobj struct */
6874         IStorageCompObj.dwOleTypeNameLength = strlen(strOleTypeName)+1;
6875         strcpy(IStorageCompObj.strOleTypeName, strOleTypeName);
6876
6877         /* copy the OleTypeName to the compobj struct */
6878         /* Note: in the test made, these were Identical      */
6879         IStorageCompObj.dwProgIDNameLength = strlen(strOleTypeName)+1;
6880         strcpy(IStorageCompObj.strProgIDName, strOleTypeName);
6881
6882         /* Get the CLSID */
6883         hRes = CLSIDFromProgID16(IStorageCompObj.strProgIDName, &(IStorageCompObj.clsid));
6884
6885         if(hRes == S_OK)
6886         {
6887             HKEY hKey;
6888             LONG hErr;
6889             /* Get the CLSID Default Name from the Registry */
6890             hErr = RegOpenKeyA(HKEY_CLASSES_ROOT, IStorageCompObj.strProgIDName, &hKey);
6891             if(hErr == ERROR_SUCCESS)
6892             {
6893                 char strTemp[OLESTREAM_MAX_STR_LEN];
6894                 IStorageCompObj.dwCLSIDNameLength = OLESTREAM_MAX_STR_LEN;
6895                 hErr = RegQueryValueA(hKey, NULL, strTemp, &(IStorageCompObj.dwCLSIDNameLength));
6896                 if(hErr == ERROR_SUCCESS)
6897                 {
6898                     strcpy(IStorageCompObj.strCLSIDName, strTemp);
6899                 }
6900                 RegCloseKey(hKey);
6901             }
6902         }
6903
6904         /* Write CompObj Structure to stream */
6905         hRes = IStream_Write(pStream, IStorageCompObj.byUnknown1, sizeof(IStorageCompObj.byUnknown1), NULL);
6906
6907         WriteClassStm(pStream,&(IStorageCompObj.clsid));
6908
6909         hRes = IStream_Write(pStream, &(IStorageCompObj.dwCLSIDNameLength), sizeof(IStorageCompObj.dwCLSIDNameLength), NULL);
6910         if(IStorageCompObj.dwCLSIDNameLength > 0)
6911         {
6912             hRes = IStream_Write(pStream, IStorageCompObj.strCLSIDName, IStorageCompObj.dwCLSIDNameLength, NULL);
6913         }
6914         hRes = IStream_Write(pStream, &(IStorageCompObj.dwOleTypeNameLength) , sizeof(IStorageCompObj.dwOleTypeNameLength), NULL);
6915         if(IStorageCompObj.dwOleTypeNameLength > 0)
6916         {
6917             hRes = IStream_Write(pStream, IStorageCompObj.strOleTypeName , IStorageCompObj.dwOleTypeNameLength, NULL);
6918         }
6919         hRes = IStream_Write(pStream, &(IStorageCompObj.dwProgIDNameLength) , sizeof(IStorageCompObj.dwProgIDNameLength), NULL);
6920         if(IStorageCompObj.dwProgIDNameLength > 0)
6921         {
6922             hRes = IStream_Write(pStream, IStorageCompObj.strProgIDName , IStorageCompObj.dwProgIDNameLength, NULL);
6923         }
6924         hRes = IStream_Write(pStream, IStorageCompObj.byUnknown2 , sizeof(IStorageCompObj.byUnknown2), NULL);
6925         IStream_Release(pStream);
6926     }
6927     return hRes;
6928 }
6929
6930
6931 /*************************************************************************
6932  * OLECONVERT_CreateOlePresStream[Internal]
6933  *
6934  * Creates the "\002OlePres000" Stream with the Metafile data
6935  *
6936  * PARAMS
6937  *     pStorage     [I] The dest IStorage to create \002OLEPres000 stream in.
6938  *     dwExtentX    [I] Width of the Metafile
6939  *     dwExtentY    [I] Height of the Metafile
6940  *     pData        [I] Metafile data
6941  *     dwDataLength [I] Size of the Metafile data
6942  *
6943  * RETURNS
6944  *     Success:  S_OK
6945  *     Failure:  CONVERT10_E_OLESTREAM_PUT for invalid Put
6946  *
6947  * NOTES
6948  *     This function is used by OleConvertOLESTREAMToIStorage only.
6949  *
6950  */
6951 void OLECONVERT_CreateOlePresStream(LPSTORAGE pStorage, DWORD dwExtentX, DWORD dwExtentY , BYTE *pData, DWORD dwDataLength)
6952 {
6953     HRESULT hRes;
6954     IStream *pStream;
6955     WCHAR wstrStreamName[] = {2, 'O', 'l', 'e', 'P', 'r', 'e', 's', '0', '0', '0', 0};
6956     BYTE pOlePresStreamHeader [] =
6957     {
6958         0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00,
6959         0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
6960         0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
6961         0x00, 0x00, 0x00, 0x00
6962     };
6963
6964     BYTE pOlePresStreamHeaderEmpty [] =
6965     {
6966         0x00, 0x00, 0x00, 0x00,
6967         0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
6968         0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
6969         0x00, 0x00, 0x00, 0x00
6970     };
6971
6972     /* Create the OlePres000 Stream */
6973     hRes = IStorage_CreateStream(pStorage, wstrStreamName,
6974         STGM_CREATE | STGM_WRITE  | STGM_SHARE_EXCLUSIVE, 0, 0, &pStream );
6975
6976     if(hRes == S_OK)
6977     {
6978         DWORD nHeaderSize;
6979         OLECONVERT_ISTORAGE_OLEPRES OlePres;
6980
6981         memset(&OlePres, 0, sizeof(OlePres));
6982         /* Do we have any metafile data to save */
6983         if(dwDataLength > 0)
6984         {
6985             memcpy(OlePres.byUnknown1, pOlePresStreamHeader, sizeof(pOlePresStreamHeader));
6986             nHeaderSize = sizeof(pOlePresStreamHeader);
6987         }
6988         else
6989         {
6990             memcpy(OlePres.byUnknown1, pOlePresStreamHeaderEmpty, sizeof(pOlePresStreamHeaderEmpty));
6991             nHeaderSize = sizeof(pOlePresStreamHeaderEmpty);
6992         }
6993         /* Set width and height of the metafile */
6994         OlePres.dwExtentX = dwExtentX;
6995         OlePres.dwExtentY = -dwExtentY;
6996
6997         /* Set Data and Length */
6998         if(dwDataLength > sizeof(METAFILEPICT16))
6999         {
7000             OlePres.dwSize = dwDataLength - sizeof(METAFILEPICT16);
7001             OlePres.pData = &(pData[8]);
7002         }
7003         /* Save OlePres000 Data to Stream */
7004         hRes = IStream_Write(pStream, OlePres.byUnknown1, nHeaderSize, NULL);
7005         hRes = IStream_Write(pStream, &(OlePres.dwExtentX), sizeof(OlePres.dwExtentX), NULL);
7006         hRes = IStream_Write(pStream, &(OlePres.dwExtentY), sizeof(OlePres.dwExtentY), NULL);
7007         hRes = IStream_Write(pStream, &(OlePres.dwSize), sizeof(OlePres.dwSize), NULL);
7008         if(OlePres.dwSize > 0)
7009         {
7010             hRes = IStream_Write(pStream, OlePres.pData, OlePres.dwSize, NULL);
7011         }
7012         IStream_Release(pStream);
7013     }
7014 }
7015
7016 /*************************************************************************
7017  * OLECONVERT_CreateOle10NativeStream [Internal]
7018  *
7019  * Creates the "\001Ole10Native" Stream (should contain a BMP)
7020  *
7021  * PARAMS
7022  *     pStorage     [I] Dest storage to create the stream in
7023  *     pData        [I] Ole10 Native Data (ex. bmp)
7024  *     dwDataLength [I] Size of the Ole10 Native Data
7025  *
7026  * RETURNS
7027  *     Nothing
7028  *
7029  * NOTES
7030  *     This function is used by OleConvertOLESTREAMToIStorage only.
7031  *
7032  *     Might need to verify the data and return appropriate error message
7033  *
7034  */
7035 void OLECONVERT_CreateOle10NativeStream(LPSTORAGE pStorage, BYTE *pData, DWORD dwDataLength)
7036 {
7037     HRESULT hRes;
7038     IStream *pStream;
7039     WCHAR wstrStreamName[] = {1, 'O', 'l', 'e', '1', '0', 'N', 'a', 't', 'i', 'v', 'e', 0};
7040
7041     /* Create the Ole10Native Stream */
7042     hRes = IStorage_CreateStream(pStorage, wstrStreamName,
7043         STGM_CREATE | STGM_WRITE  | STGM_SHARE_EXCLUSIVE, 0, 0, &pStream );
7044
7045     if(hRes == S_OK)
7046     {
7047         /* Write info to stream */
7048         hRes = IStream_Write(pStream, &dwDataLength, sizeof(dwDataLength), NULL);
7049         hRes = IStream_Write(pStream, pData, dwDataLength, NULL);
7050         IStream_Release(pStream);
7051     }
7052
7053 }
7054
7055 /*************************************************************************
7056  * OLECONVERT_GetOLE10ProgID [Internal]
7057  *
7058  * Finds the ProgID (or OleTypeID) from the IStorage
7059  *
7060  * PARAMS
7061  *     pStorage        [I] The Src IStorage to get the ProgID
7062  *     strProgID       [I] the ProgID string to get
7063  *     dwSize          [I] the size of the string
7064  *
7065  * RETURNS
7066  *     Success:  S_OK
7067  *     Failure:  REGDB_E_CLASSNOTREG if cannot reconstruct the stream
7068  *
7069  * NOTES
7070  *     This function is used by OleConvertIStorageToOLESTREAM only.
7071  *
7072  *
7073  */
7074 HRESULT OLECONVERT_GetOLE10ProgID(LPSTORAGE pStorage, char *strProgID, DWORD *dwSize)
7075 {
7076     HRESULT hRes;
7077     IStream *pStream;
7078     LARGE_INTEGER iSeekPos;
7079     OLECONVERT_ISTORAGE_COMPOBJ CompObj;
7080     WCHAR wstrStreamName[] = {1,'C', 'o', 'm', 'p', 'O', 'b', 'j', 0};
7081
7082     /* Open the CompObj Stream */
7083     hRes = IStorage_OpenStream(pStorage, wstrStreamName, NULL,
7084         STGM_READ  | STGM_SHARE_EXCLUSIVE, 0, &pStream );
7085     if(hRes == S_OK)
7086     {
7087
7088         /*Get the OleType from the CompObj Stream */
7089         iSeekPos.s.LowPart = sizeof(CompObj.byUnknown1) + sizeof(CompObj.clsid);
7090         iSeekPos.s.HighPart = 0;
7091
7092         IStream_Seek(pStream, iSeekPos, STREAM_SEEK_SET, NULL);
7093         IStream_Read(pStream, &CompObj.dwCLSIDNameLength, sizeof(CompObj.dwCLSIDNameLength), NULL);
7094         iSeekPos.s.LowPart = CompObj.dwCLSIDNameLength;
7095         IStream_Seek(pStream, iSeekPos, STREAM_SEEK_CUR , NULL);
7096         IStream_Read(pStream, &CompObj.dwOleTypeNameLength, sizeof(CompObj.dwOleTypeNameLength), NULL);
7097         iSeekPos.s.LowPart = CompObj.dwOleTypeNameLength;
7098         IStream_Seek(pStream, iSeekPos, STREAM_SEEK_CUR , NULL);
7099
7100         IStream_Read(pStream, dwSize, sizeof(*dwSize), NULL);
7101         if(*dwSize > 0)
7102         {
7103             IStream_Read(pStream, strProgID, *dwSize, NULL);
7104         }
7105         IStream_Release(pStream);
7106     }
7107     else
7108     {
7109         STATSTG stat;
7110         LPOLESTR wstrProgID;
7111
7112         /* Get the OleType from the registry */
7113         REFCLSID clsid = &(stat.clsid);
7114         IStorage_Stat(pStorage, &stat, STATFLAG_NONAME);
7115         hRes = ProgIDFromCLSID(clsid, &wstrProgID);
7116         if(hRes == S_OK)
7117         {
7118             *dwSize = WideCharToMultiByte(CP_ACP, 0, wstrProgID, -1, strProgID, *dwSize, NULL, FALSE);
7119         }
7120
7121     }
7122     return hRes;
7123 }
7124
7125 /*************************************************************************
7126  * OLECONVERT_GetOle10PresData [Internal]
7127  *
7128  * Converts IStorage "/001Ole10Native" stream to a OLE10 Stream
7129  *
7130  * PARAMS
7131  *     pStorage     [I] Src IStroage
7132  *     pOleStream   [I] Dest OleStream Mem Struct
7133  *
7134  * RETURNS
7135  *     Nothing
7136  *
7137  * NOTES
7138  *     This function is used by OleConvertIStorageToOLESTREAM only.
7139  *
7140  *     Memory allocated for pData must be freed by the caller
7141  *
7142  *
7143  */
7144 void OLECONVERT_GetOle10PresData(LPSTORAGE pStorage, OLECONVERT_OLESTREAM_DATA *pOleStreamData)
7145 {
7146
7147     HRESULT hRes;
7148     IStream *pStream;
7149     WCHAR wstrStreamName[] = {1, 'O', 'l', 'e', '1', '0', 'N', 'a', 't', 'i', 'v', 'e', 0};
7150
7151     /* Initialize Default data for OLESTREAM */
7152     pOleStreamData[0].dwOleID = OLESTREAM_ID;
7153     pOleStreamData[0].dwTypeID = 2;
7154     pOleStreamData[1].dwOleID = OLESTREAM_ID;
7155     pOleStreamData[1].dwTypeID = 0;
7156     pOleStreamData[0].dwMetaFileWidth = 0;
7157     pOleStreamData[0].dwMetaFileHeight = 0;
7158     pOleStreamData[0].pData = NULL;
7159     pOleStreamData[1].pData = NULL;
7160
7161     /* Open Ole10Native Stream */
7162     hRes = IStorage_OpenStream(pStorage, wstrStreamName, NULL,
7163         STGM_READ  | STGM_SHARE_EXCLUSIVE, 0, &pStream );
7164     if(hRes == S_OK)
7165     {
7166
7167         /* Read Size and Data */
7168         IStream_Read(pStream, &(pOleStreamData->dwDataLength), sizeof(pOleStreamData->dwDataLength), NULL);
7169         if(pOleStreamData->dwDataLength > 0)
7170         {
7171             pOleStreamData->pData = (LPSTR) HeapAlloc(GetProcessHeap(),0,pOleStreamData->dwDataLength);
7172             IStream_Read(pStream, pOleStreamData->pData, pOleStreamData->dwDataLength, NULL);
7173         }
7174         IStream_Release(pStream);
7175     }
7176
7177 }
7178
7179
7180 /*************************************************************************
7181  * OLECONVERT_GetOle20PresData[Internal]
7182  *
7183  * Converts IStorage "/002OlePres000" stream to a OLE10 Stream
7184  *
7185  * PARAMS
7186  *     pStorage         [I] Src IStroage
7187  *     pOleStreamData   [I] Dest OleStream Mem Struct
7188  *
7189  * RETURNS
7190  *     Nothing
7191  *
7192  * NOTES
7193  *     This function is used by OleConvertIStorageToOLESTREAM only.
7194  *
7195  *     Memory allocated for pData must be freed by the caller
7196  */
7197 void OLECONVERT_GetOle20PresData(LPSTORAGE pStorage, OLECONVERT_OLESTREAM_DATA *pOleStreamData)
7198 {
7199     HRESULT hRes;
7200     IStream *pStream;
7201     OLECONVERT_ISTORAGE_OLEPRES olePress;
7202     WCHAR wstrStreamName[] = {2, 'O', 'l', 'e', 'P', 'r', 'e', 's', '0', '0', '0', 0};
7203
7204     /* Initialize Default data for OLESTREAM */
7205     pOleStreamData[0].dwOleID = OLESTREAM_ID;
7206     pOleStreamData[0].dwTypeID = 2;
7207     pOleStreamData[0].dwMetaFileWidth = 0;
7208     pOleStreamData[0].dwMetaFileHeight = 0;
7209     pOleStreamData[0].dwDataLength = OLECONVERT_WriteOLE20ToBuffer(pStorage, &(pOleStreamData[0].pData));
7210     pOleStreamData[1].dwOleID = OLESTREAM_ID;
7211     pOleStreamData[1].dwTypeID = 0;
7212     pOleStreamData[1].dwOleTypeNameLength = 0;
7213     pOleStreamData[1].strOleTypeName[0] = 0;
7214     pOleStreamData[1].dwMetaFileWidth = 0;
7215     pOleStreamData[1].dwMetaFileHeight = 0;
7216     pOleStreamData[1].pData = NULL;
7217     pOleStreamData[1].dwDataLength = 0;
7218
7219
7220     /* Open OlePress000 stream */
7221     hRes = IStorage_OpenStream(pStorage, wstrStreamName, NULL,
7222         STGM_READ  | STGM_SHARE_EXCLUSIVE, 0, &pStream );
7223     if(hRes == S_OK)
7224     {
7225         LARGE_INTEGER iSeekPos;
7226         METAFILEPICT16 MetaFilePict;
7227         char strMetafilePictName[] = "METAFILEPICT";
7228
7229         /* Set the TypeID for a Metafile */
7230         pOleStreamData[1].dwTypeID = 5;
7231
7232         /* Set the OleTypeName to Metafile */
7233         pOleStreamData[1].dwOleTypeNameLength = strlen(strMetafilePictName) +1;
7234         strcpy(pOleStreamData[1].strOleTypeName, strMetafilePictName);
7235
7236         iSeekPos.s.HighPart = 0;
7237         iSeekPos.s.LowPart = sizeof(olePress.byUnknown1);
7238
7239         /* Get Presentation Data */
7240         IStream_Seek(pStream, iSeekPos, STREAM_SEEK_SET, NULL);
7241         IStream_Read(pStream, &(olePress.dwExtentX), sizeof(olePress.dwExtentX), NULL);
7242         IStream_Read(pStream, &(olePress.dwExtentY), sizeof(olePress.dwExtentY), NULL);
7243         IStream_Read(pStream, &(olePress.dwSize), sizeof(olePress.dwSize), NULL);
7244
7245         /*Set width and Height */
7246         pOleStreamData[1].dwMetaFileWidth = olePress.dwExtentX;
7247         pOleStreamData[1].dwMetaFileHeight = -olePress.dwExtentY;
7248         if(olePress.dwSize > 0)
7249         {
7250             /* Set Length */
7251             pOleStreamData[1].dwDataLength  = olePress.dwSize + sizeof(METAFILEPICT16);
7252
7253             /* Set MetaFilePict struct */
7254             MetaFilePict.mm = 8;
7255             MetaFilePict.xExt = olePress.dwExtentX;
7256             MetaFilePict.yExt = olePress.dwExtentY;
7257             MetaFilePict.hMF = 0;
7258
7259             /* Get Metafile Data */
7260             pOleStreamData[1].pData = (BYTE *) HeapAlloc(GetProcessHeap(),0,pOleStreamData[1].dwDataLength);
7261             memcpy(pOleStreamData[1].pData, &MetaFilePict, sizeof(MetaFilePict));
7262             IStream_Read(pStream, &(pOleStreamData[1].pData[sizeof(MetaFilePict)]), pOleStreamData[1].dwDataLength-sizeof(METAFILEPICT16), NULL);
7263         }
7264         IStream_Release(pStream);
7265     }
7266 }
7267
7268 /*************************************************************************
7269  * OleConvertOLESTREAMToIStorage [OLE32.@]
7270  *
7271  * Read info on MSDN
7272  *
7273  * TODO
7274  *      DVTARGETDEVICE paramenter is not handled
7275  *      Still unsure of some mem fields for OLE 10 Stream
7276  *      Still some unknowns for the IStorage: "\002OlePres000", "\001CompObj",
7277  *      and "\001OLE" streams
7278  *
7279  */
7280 HRESULT WINAPI OleConvertOLESTREAMToIStorage (
7281     LPOLESTREAM pOleStream,
7282     LPSTORAGE pstg,
7283     const DVTARGETDEVICE* ptd)
7284 {
7285     int i;
7286     HRESULT hRes=S_OK;
7287     OLECONVERT_OLESTREAM_DATA pOleStreamData[2];
7288
7289     memset(pOleStreamData, 0, sizeof(pOleStreamData));
7290
7291     if(ptd != NULL)
7292     {
7293         FIXME("DVTARGETDEVICE is not NULL, unhandled parameter\n");
7294     }
7295
7296     if(pstg == NULL || pOleStream == NULL)
7297     {
7298         hRes = E_INVALIDARG;
7299     }
7300
7301     if(hRes == S_OK)
7302     {
7303         /* Load the OLESTREAM to Memory */
7304         hRes = OLECONVERT_LoadOLE10(pOleStream, &pOleStreamData[0], TRUE);
7305     }
7306
7307     if(hRes == S_OK)
7308     {
7309         /* Load the OLESTREAM to Memory (part 2)*/
7310         hRes = OLECONVERT_LoadOLE10(pOleStream, &pOleStreamData[1], FALSE);
7311     }
7312
7313     if(hRes == S_OK)
7314     {
7315
7316         if(pOleStreamData[0].dwDataLength > sizeof(STORAGE_magic))
7317         {
7318             /* Do we have the IStorage Data in the OLESTREAM */
7319             if(memcmp(pOleStreamData[0].pData, STORAGE_magic, sizeof(STORAGE_magic)) ==0)
7320             {
7321                 OLECONVERT_GetOLE20FromOLE10(pstg, pOleStreamData[0].pData, pOleStreamData[0].dwDataLength);
7322                 OLECONVERT_CreateOlePresStream(pstg, pOleStreamData[1].dwMetaFileWidth, pOleStreamData[1].dwMetaFileHeight, pOleStreamData[1].pData, pOleStreamData[1].dwDataLength);
7323             }
7324             else
7325             {
7326                 /* It must be an original OLE 1.0 source */
7327                 OLECONVERT_CreateOle10NativeStream(pstg, pOleStreamData[0].pData, pOleStreamData[0].dwDataLength);
7328             }
7329         }
7330         else
7331         {
7332             /* It must be an original OLE 1.0 source */
7333             OLECONVERT_CreateOle10NativeStream(pstg, pOleStreamData[0].pData, pOleStreamData[0].dwDataLength);
7334         }
7335
7336         /* Create CompObj Stream if necessary */
7337         hRes = OLECONVERT_CreateCompObjStream(pstg, pOleStreamData[0].strOleTypeName);
7338         if(hRes == S_OK)
7339         {
7340             /*Create the Ole Stream if necessary */
7341             OLECONVERT_CreateOleStream(pstg);
7342         }
7343     }
7344
7345
7346     /* Free allocated memory */
7347     for(i=0; i < 2; i++)
7348     {
7349         if(pOleStreamData[i].pData != NULL)
7350         {
7351             HeapFree(GetProcessHeap(),0,pOleStreamData[i].pData);
7352         }
7353         if(pOleStreamData[i].pstrOleObjFileName != NULL)
7354         {
7355                 HeapFree(GetProcessHeap(),0,pOleStreamData[i].pstrOleObjFileName);
7356                 pOleStreamData[i].pstrOleObjFileName = NULL;
7357         }
7358     }
7359     return hRes;
7360 }
7361
7362 /*************************************************************************
7363  * OleConvertIStorageToOLESTREAM [OLE32.@]
7364  *
7365  * Read info on MSDN
7366  *
7367  * Read info on MSDN
7368  *
7369  * TODO
7370  *      Still unsure of some mem fields for OLE 10 Stream
7371  *      Still some unknowns for the IStorage: "\002OlePres000", "\001CompObj",
7372  *      and "\001OLE" streams.
7373  *
7374  */
7375 HRESULT WINAPI OleConvertIStorageToOLESTREAM (
7376     LPSTORAGE pstg,
7377     LPOLESTREAM pOleStream)
7378 {
7379     int i;
7380     HRESULT hRes = S_OK;
7381     IStream *pStream;
7382     OLECONVERT_OLESTREAM_DATA pOleStreamData[2];
7383     WCHAR wstrStreamName[] = {1, 'O', 'l', 'e', '1', '0', 'N', 'a', 't', 'i', 'v', 'e', 0};
7384
7385
7386     memset(pOleStreamData, 0, sizeof(pOleStreamData));
7387
7388     if(pstg == NULL || pOleStream == NULL)
7389     {
7390         hRes = E_INVALIDARG;
7391     }
7392     if(hRes == S_OK)
7393     {
7394         /* Get the ProgID */
7395         pOleStreamData[0].dwOleTypeNameLength = OLESTREAM_MAX_STR_LEN;
7396         hRes = OLECONVERT_GetOLE10ProgID(pstg, pOleStreamData[0].strOleTypeName, &(pOleStreamData[0].dwOleTypeNameLength));
7397     }
7398     if(hRes == S_OK)
7399     {
7400         /* Was it originally Ole10 */
7401         hRes = IStorage_OpenStream(pstg, wstrStreamName, 0, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &pStream);
7402         if(hRes == S_OK)
7403         {
7404             IStream_Release(pStream);
7405             /* Get Presentation Data for Ole10Native */
7406             OLECONVERT_GetOle10PresData(pstg, pOleStreamData);
7407         }
7408         else
7409         {
7410             /* Get Presentation Data (OLE20) */
7411             OLECONVERT_GetOle20PresData(pstg, pOleStreamData);
7412         }
7413
7414         /* Save OLESTREAM */
7415         hRes = OLECONVERT_SaveOLE10(&(pOleStreamData[0]), pOleStream);
7416         if(hRes == S_OK)
7417         {
7418             hRes = OLECONVERT_SaveOLE10(&(pOleStreamData[1]), pOleStream);
7419         }
7420
7421     }
7422
7423     /* Free allocated memory */
7424     for(i=0; i < 2; i++)
7425     {
7426         if(pOleStreamData[i].pData != NULL)
7427         {
7428             HeapFree(GetProcessHeap(),0,pOleStreamData[i].pData);
7429         }
7430     }
7431
7432     return hRes;
7433 }
7434
7435 /***********************************************************************
7436  *              GetConvertStg (OLE32.@)
7437  */
7438 HRESULT WINAPI GetConvertStg(LPGUID guid) {
7439     FIXME("(%s), unimplemented stub!\n",debugstr_guid(guid));
7440     return E_FAIL;
7441 }
7442
7443 /******************************************************************************
7444  * StgIsStorageFile [OLE32.@]
7445  */
7446 HRESULT WINAPI
7447 StgIsStorageFile(LPCOLESTR fn)
7448 {
7449         HANDLE          hf;
7450         BYTE            magic[8];
7451         DWORD           bytes_read;
7452
7453         TRACE("(\'%s\')\n", debugstr_w(fn));
7454         hf = CreateFileW(fn, GENERIC_READ,
7455                          FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
7456                          NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
7457
7458         if (hf == INVALID_HANDLE_VALUE)
7459                 return STG_E_FILENOTFOUND;
7460
7461         if (!ReadFile(hf, magic, 8, &bytes_read, NULL))
7462         {
7463                 WARN(" unable to read file\n");
7464                 CloseHandle(hf);
7465                 return S_FALSE;
7466         }
7467
7468         CloseHandle(hf);
7469
7470         if (bytes_read != 8) {
7471                 WARN(" too short\n");
7472                 return S_FALSE;
7473         }
7474
7475         if (!memcmp(magic,STORAGE_magic,8)) {
7476                 WARN(" -> YES\n");
7477                 return S_OK;
7478         }
7479
7480         WARN(" -> Invalid header.\n");
7481         return S_FALSE;
7482 }