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

   1 /*
   2  * Compound Storage (32 bit version)
   3  * Stream implementation
   4  *
   5  * This file contains the implementation of the stream interface
   6  * for streams contained in a compound storage.
   7  *
   8  * Copyright 1999 Francis Beaudet
   9  * Copyright 1999 Thuy Nguyen
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with this library; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24  */
  25
  26 #include <assert.h>
  27 #include <stdlib.h>
  28 #include <stdarg.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31
  32 #define COBJMACROS
  33 #define NONAMELESSUNION
  34 #define NONAMELESSSTRUCT
  35
  36 #include "windef.h"
  37 #include "winbase.h"
  38 #include "winerror.h"
  39 #include "winreg.h"
  40 #include "winternl.h"
  41 #include "wine/debug.h"
  42
  43 #include "storage32.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(storage);
  46
  47
  48 /***
  49  * This is the destructor of the StgStreamImpl class.
  50  *
  51  * This method will clean-up all the resources used-up by the given StgStreamImpl
  52  * class. The pointer passed-in to this function will be freed and will not
  53  * be valid anymore.
  54  */
  55 static void StgStreamImpl_Destroy(StgStreamImpl* This)
  56 {
  57   TRACE("(%p)\n", This);
  58
  59   /*
  60    * Release the reference we are holding on the parent storage.
  61    */
  62   IStorage_Release((IStorage*)This->parentStorage);
  63   This->parentStorage = 0;
  64
  65   /*
  66    * Make sure we clean-up the block chain stream objects that we were using.
  67    */
  68   if (This->bigBlockChain != 0)
  69   {
  70     BlockChainStream_Destroy(This->bigBlockChain);
  71     This->bigBlockChain = 0;
  72   }
  73
  74   if (This->smallBlockChain != 0)
  75   {
  76     SmallBlockChainStream_Destroy(This->smallBlockChain);
  77     This->smallBlockChain = 0;
  78   }
  79
  80   /*
  81    * Finally, free the memory used-up by the class.
  82    */
  83   HeapFree(GetProcessHeap(), 0, This);
  84 }
  85
  86 /***
  87  * This implements the IUnknown method QueryInterface for this
  88  * class
  89  */
  90 static HRESULT WINAPI StgStreamImpl_QueryInterface(
  91                   IStream*     iface,
  92                   REFIID         riid,        /* [in] */
  93                   void**         ppvObject)   /* [iid_is][out] */
  94 {
  95   StgStreamImpl* const This=(StgStreamImpl*)iface;
  96
  97   /*
  98    * Perform a sanity check on the parameters.
  99    */
 100   if (ppvObject==0)
 101     return E_INVALIDARG;
 102
 103   /*
 104    * Initialize the return parameter.
 105    */
 106   *ppvObject = 0;
 107
 108   /*
 109    * Compare the riid with the interface IDs implemented by this object.
 110    */
 111   if (IsEqualGUID(&IID_IUnknown, riid)||
 112       IsEqualGUID(&IID_IStream, riid))
 113   {
 114     *ppvObject = (IStream*)This;
 115   }
 116
 117   /*
 118    * Check that we obtained an interface.
 119    */
 120   if ((*ppvObject)==0)
 121     return E_NOINTERFACE;
 122
 123   /*
 124    * Query Interface always increases the reference count by one when it is
 125    * successful
 126    */
 127   IStream_AddRef(iface);
 128
 129   return S_OK;
 130 }
 131
 132 /***
 133  * This implements the IUnknown method AddRef for this
 134  * class
 135  */
 136 static ULONG WINAPI StgStreamImpl_AddRef(
 137                 IStream* iface)
 138 {
 139   StgStreamImpl* const This=(StgStreamImpl*)iface;
 140   return InterlockedIncrement(&This->ref);
 141 }
 142
 143 /***
 144  * This implements the IUnknown method Release for this
 145  * class
 146  */
 147 static ULONG WINAPI StgStreamImpl_Release(
 148                 IStream* iface)
 149 {
 150   StgStreamImpl* const This=(StgStreamImpl*)iface;
 151
 152   ULONG ref;
 153
 154   ref = InterlockedDecrement(&This->ref);
 155
 156   /*
 157    * If the reference count goes down to 0, perform suicide.
 158    */
 159   if (ref==0)
 160   {
 161     StgStreamImpl_Destroy(This);
 162   }
 163
 164   return ref;
 165 }
 166
 167 /***
 168  * This method will open the block chain pointed by the property
 169  * that describes the stream.
 170  * If the stream's size is null, no chain is opened.
 171  */
 172 static void StgStreamImpl_OpenBlockChain(
 173         StgStreamImpl* This)
 174 {
 175   StgProperty    curProperty;
 176   BOOL         readSucessful;
 177
 178   /*
 179    * Make sure no old object is left over.
 180    */
 181   if (This->smallBlockChain != 0)
 182   {
 183     SmallBlockChainStream_Destroy(This->smallBlockChain);
 184     This->smallBlockChain = 0;
 185   }
 186
 187   if (This->bigBlockChain != 0)
 188   {
 189     BlockChainStream_Destroy(This->bigBlockChain);
 190     This->bigBlockChain = 0;
 191   }
 192
 193   /*
 194    * Read the information from the property.
 195    */
 196   readSucessful = StorageImpl_ReadProperty(This->parentStorage->ancestorStorage,
 197                                              This->ownerProperty,
 198                                              &curProperty);
 199
 200   if (readSucessful)
 201   {
 202     This->streamSize = curProperty.size;
 203
 204     /*
 205      * This code supports only streams that are <32 bits in size.
 206      */
 207     assert(This->streamSize.u.HighPart == 0);
 208
 209     if(curProperty.startingBlock == BLOCK_END_OF_CHAIN)
 210     {
 211       assert( (This->streamSize.u.HighPart == 0) && (This->streamSize.u.LowPart == 0) );
 212     }
 213     else
 214     {
 215       if ( (This->streamSize.u.HighPart == 0) &&
 216            (This->streamSize.u.LowPart < LIMIT_TO_USE_SMALL_BLOCK) )
 217       {
 218         This->smallBlockChain = SmallBlockChainStream_Construct(
 219                                                                 This->parentStorage->ancestorStorage,
 220                                                                 This->ownerProperty);
 221       }
 222       else
 223       {
 224         This->bigBlockChain = BlockChainStream_Construct(
 225                                                          This->parentStorage->ancestorStorage,
 226                                                          NULL,
 227                                                          This->ownerProperty);
 228       }
 229     }
 230   }
 231 }
 232
 233 /***
 234  * This method is part of the ISequentialStream interface.
 235  *
 236  * It reads a block of information from the stream at the current
 237  * position. It then moves the current position at the end of the
 238  * read block
 239  *
 240  * See the documentation of ISequentialStream for more info.
 241  */
 242 static HRESULT WINAPI StgStreamImpl_Read(
 243                   IStream*     iface,
 244                   void*          pv,        /* [length_is][size_is][out] */
 245                   ULONG          cb,        /* [in] */
 246                   ULONG*         pcbRead)   /* [out] */
 247 {
 248   StgStreamImpl* const This=(StgStreamImpl*)iface;
 249
 250   ULONG bytesReadBuffer;
 251   ULONG bytesToReadFromBuffer;
 252   HRESULT res = S_FALSE;
 253
 254   TRACE("(%p, %p, %ld, %p)\n",
 255         iface, pv, cb, pcbRead);
 256
 257   /*
 258    * If the caller is not interested in the number of bytes read,
 259    * we use another buffer to avoid "if" statements in the code.
 260    */
 261   if (pcbRead==0)
 262     pcbRead = &bytesReadBuffer;
 263
 264   /*
 265    * Using the known size of the stream, calculate the number of bytes
 266    * to read from the block chain
 267    */
 268   bytesToReadFromBuffer = min( This->streamSize.u.LowPart - This->currentPosition.u.LowPart, cb);
 269
 270   /*
 271    * Depending on the type of chain that was opened when the stream was constructed,
 272    * we delegate the work to the method that reads the block chains.
 273    */
 274   if (This->smallBlockChain!=0)
 275   {
 276     SmallBlockChainStream_ReadAt(This->smallBlockChain,
 277                                  This->currentPosition,
 278                                  bytesToReadFromBuffer,
 279                                  pv,
 280                                  pcbRead);
 281
 282   }
 283   else if (This->bigBlockChain!=0)
 284   {
 285     BlockChainStream_ReadAt(This->bigBlockChain,
 286                             This->currentPosition,
 287                             bytesToReadFromBuffer,
 288                             pv,
 289                             pcbRead);
 290   }
 291   else
 292   {
 293     /*
 294      * Small and big block chains are both NULL. This case will happen
 295      * when a stream starts with BLOCK_END_OF_CHAIN and has size zero.
 296      */
 297
 298     *pcbRead = 0;
 299     res = S_OK;
 300     goto end;
 301   }
 302
 303   /*
 304    * We should always be able to read the proper amount of data from the
 305    * chain.
 306    */
 307   assert(bytesToReadFromBuffer == *pcbRead);
 308
 309   /*
 310    * Advance the pointer for the number of positions read.
 311    */
 312   This->currentPosition.u.LowPart += *pcbRead;
 313
 314   if(*pcbRead != cb)
 315   {
 316     WARN("read %ld instead of the required %ld bytes !\n", *pcbRead, cb);
 317     /*
 318      * this used to return S_FALSE, however MSDN docu says that an app should
 319      * be prepared to handle error in case of stream end reached, as *some*
 320      * implementations *might* return an error (IOW: most do *not*).
 321      * As some program fails on returning S_FALSE, I better use S_OK here.
 322      */
 323     res = S_OK;
 324   }
 325   else
 326     res = S_OK;
 327
 328 end:
 329   TRACE("<-- %08lx\n", res);
 330   return res;
 331 }
 332
 333 /***
 334  * This method is part of the ISequentialStream interface.
 335  *
 336  * It writes a block of information to the stream at the current
 337  * position. It then moves the current position at the end of the
 338  * written block. If the stream is too small to fit the block,
 339  * the stream is grown to fit.
 340  *
 341  * See the documentation of ISequentialStream for more info.
 342  */
 343 static HRESULT WINAPI StgStreamImpl_Write(
 344                   IStream*     iface,
 345                   const void*    pv,          /* [size_is][in] */
 346                   ULONG          cb,          /* [in] */
 347                   ULONG*         pcbWritten)  /* [out] */
 348 {
 349   StgStreamImpl* const This=(StgStreamImpl*)iface;
 350
 351   ULARGE_INTEGER newSize;
 352   ULONG bytesWritten = 0;
 353
 354   TRACE("(%p, %p, %ld, %p)\n",
 355         iface, pv, cb, pcbWritten);
 356
 357   /*
 358    * Do we have permission to write to this stream?
 359    */
 360   switch(STGM_ACCESS_MODE(This->grfMode))
 361   {
 362   case STGM_WRITE:
 363   case STGM_READWRITE:
 364       break;
 365   default:
 366       return STG_E_ACCESSDENIED;
 367   }
 368
 369   if (!pv)
 370     return STG_E_INVALIDPOINTER;
 371
 372   /*
 373    * If the caller is not interested in the number of bytes written,
 374    * we use another buffer to avoid "if" statements in the code.
 375    */
 376   if (pcbWritten == 0)
 377     pcbWritten = &bytesWritten;
 378
 379   /*
 380    * Initialize the out parameter
 381    */
 382   *pcbWritten = 0;
 383
 384   if (cb == 0)
 385   {
 386     return S_OK;
 387   }
 388   else
 389   {
 390     newSize.u.HighPart = 0;
 391     newSize.u.LowPart = This->currentPosition.u.LowPart + cb;
 392   }
 393
 394   /*
 395    * Verify if we need to grow the stream
 396    */
 397   if (newSize.u.LowPart > This->streamSize.u.LowPart)
 398   {
 399     /* grow stream */
 400     IStream_SetSize(iface, newSize);
 401   }
 402
 403   /*
 404    * Depending on the type of chain that was opened when the stream was constructed,
 405    * we delegate the work to the method that readwrites to the block chains.
 406    */
 407   if (This->smallBlockChain!=0)
 408   {
 409     SmallBlockChainStream_WriteAt(This->smallBlockChain,
 410                                   This->currentPosition,
 411                                   cb,
 412                                   pv,
 413                                   pcbWritten);
 414
 415   }
 416   else if (This->bigBlockChain!=0)
 417   {
 418     BlockChainStream_WriteAt(This->bigBlockChain,
 419                              This->currentPosition,
 420                              cb,
 421                              pv,
 422                              pcbWritten);
 423   }
 424   else
 425     assert(FALSE);
 426
 427   /*
 428    * Advance the position pointer for the number of positions written.
 429    */
 430   This->currentPosition.u.LowPart += *pcbWritten;
 431
 432   return S_OK;
 433 }
 434
 435 /***
 436  * This method is part of the IStream interface.
 437  *
 438  * It will move the current stream pointer according to the parameters
 439  * given.
 440  *
 441  * See the documentation of IStream for more info.
 442  */
 443 static HRESULT WINAPI StgStreamImpl_Seek(
 444                   IStream*      iface,
 445                   LARGE_INTEGER   dlibMove,         /* [in] */
 446                   DWORD           dwOrigin,         /* [in] */
 447                   ULARGE_INTEGER* plibNewPosition) /* [out] */
 448 {
 449   StgStreamImpl* const This=(StgStreamImpl*)iface;
 450
 451   ULARGE_INTEGER newPosition;
 452
 453   TRACE("(%p, %ld, %ld, %p)\n",
 454         iface, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
 455
 456   /*
 457    * The caller is allowed to pass in NULL as the new position return value.
 458    * If it happens, we assign it to a dynamic variable to avoid special cases
 459    * in the code below.
 460    */
 461   if (plibNewPosition == 0)
 462   {
 463     plibNewPosition = &newPosition;
 464   }
 465
 466   /*
 467    * The file pointer is moved depending on the given "function"
 468    * parameter.
 469    */
 470   switch (dwOrigin)
 471   {
 472     case STREAM_SEEK_SET:
 473       plibNewPosition->u.HighPart = 0;
 474       plibNewPosition->u.LowPart  = 0;
 475       break;
 476     case STREAM_SEEK_CUR:
 477       *plibNewPosition = This->currentPosition;
 478       break;
 479     case STREAM_SEEK_END:
 480       *plibNewPosition = This->streamSize;
 481       break;
 482     default:
 483       return STG_E_INVALIDFUNCTION;
 484   }
 485
 486   plibNewPosition->QuadPart = RtlLargeIntegerAdd( plibNewPosition->QuadPart, dlibMove.QuadPart );
 487
 488   /*
 489    * tell the caller what we calculated
 490    */
 491   This->currentPosition = *plibNewPosition;
 492
 493   return S_OK;
 494 }
 495
 496 /***
 497  * This method is part of the IStream interface.
 498  *
 499  * It will change the size of a stream.
 500  *
 501  * TODO: Switch from small blocks to big blocks and vice versa.
 502  *
 503  * See the documentation of IStream for more info.
 504  */
 505 static HRESULT WINAPI StgStreamImpl_SetSize(
 506                                      IStream*      iface,
 507                                      ULARGE_INTEGER  libNewSize)   /* [in] */
 508 {
 509   StgStreamImpl* const This=(StgStreamImpl*)iface;
 510
 511   StgProperty    curProperty;
 512   BOOL         Success;
 513
 514   TRACE("(%p, %ld)\n", iface, libNewSize.u.LowPart);
 515
 516   /*
 517    * As documented.
 518    */
 519   if (libNewSize.u.HighPart != 0)
 520     return STG_E_INVALIDFUNCTION;
 521
 522   /*
 523    * Do we have permission?
 524    */
 525   if (!(This->grfMode & (STGM_WRITE | STGM_READWRITE)))
 526     return STG_E_ACCESSDENIED;
 527
 528   if (This->streamSize.u.LowPart == libNewSize.u.LowPart)
 529     return S_OK;
 530
 531   /*
 532    * This will happen if we're creating a stream
 533    */
 534   if ((This->smallBlockChain == 0) && (This->bigBlockChain == 0))
 535   {
 536     if (libNewSize.u.LowPart < LIMIT_TO_USE_SMALL_BLOCK)
 537     {
 538       This->smallBlockChain = SmallBlockChainStream_Construct(
 539                                     This->parentStorage->ancestorStorage,
 540                                     This->ownerProperty);
 541     }
 542     else
 543     {
 544       This->bigBlockChain = BlockChainStream_Construct(
 545                                 This->parentStorage->ancestorStorage,
 546                                 NULL,
 547                                 This->ownerProperty);
 548     }
 549   }
 550
 551   /*
 552    * Read this stream's property to see if it's small blocks or big blocks
 553    */
 554   Success = StorageImpl_ReadProperty(This->parentStorage->ancestorStorage,
 555                                        This->ownerProperty,
 556                                        &curProperty);
 557   /*
 558    * Determine if we have to switch from small to big blocks or vice versa
 559    */
 560   if ( (This->smallBlockChain!=0) &&
 561        (curProperty.size.u.LowPart < LIMIT_TO_USE_SMALL_BLOCK) )
 562   {
 563     if (libNewSize.u.LowPart >= LIMIT_TO_USE_SMALL_BLOCK)
 564     {
 565       /*
 566        * Transform the small block chain into a big block chain
 567        */
 568       This->bigBlockChain = Storage32Impl_SmallBlocksToBigBlocks(
 569                                 This->parentStorage->ancestorStorage,
 570                                 &This->smallBlockChain);
 571     }
 572   }
 573
 574   if (This->smallBlockChain!=0)
 575   {
 576     Success = SmallBlockChainStream_SetSize(This->smallBlockChain, libNewSize);
 577   }
 578   else
 579   {
 580     Success = BlockChainStream_SetSize(This->bigBlockChain, libNewSize);
 581   }
 582
 583   /*
 584    * Write the new information about this stream to the property
 585    */
 586   Success = StorageImpl_ReadProperty(This->parentStorage->ancestorStorage,
 587                                        This->ownerProperty,
 588                                        &curProperty);
 589
 590   curProperty.size.u.HighPart = libNewSize.u.HighPart;
 591   curProperty.size.u.LowPart = libNewSize.u.LowPart;
 592
 593   if (Success)
 594   {
 595     StorageImpl_WriteProperty(This->parentStorage->ancestorStorage,
 596                                 This->ownerProperty,
 597                                 &curProperty);
 598   }
 599
 600   This->streamSize = libNewSize;
 601
 602   return S_OK;
 603 }
 604
 605 /***
 606  * This method is part of the IStream interface.
 607  *
 608  * It will copy the 'cb' Bytes to 'pstm' IStream.
 609  *
 610  * See the documentation of IStream for more info.
 611  */
 612 static HRESULT WINAPI StgStreamImpl_CopyTo(
 613                                     IStream*      iface,
 614                                     IStream*      pstm,         /* [unique][in] */
 615                                     ULARGE_INTEGER  cb,           /* [in] */
 616                                     ULARGE_INTEGER* pcbRead,      /* [out] */
 617                                     ULARGE_INTEGER* pcbWritten)   /* [out] */
 618 {
 619   HRESULT        hr = S_OK;
 620   BYTE           tmpBuffer[128];
 621   ULONG          bytesRead, bytesWritten, copySize;
 622   ULARGE_INTEGER totalBytesRead;
 623   ULARGE_INTEGER totalBytesWritten;
 624
 625   TRACE("(%p, %p, %ld, %p, %p)\n",
 626         iface, pstm, cb.u.LowPart, pcbRead, pcbWritten);
 627
 628   /*
 629    * Sanity check
 630    */
 631   if ( pstm == 0 )
 632     return STG_E_INVALIDPOINTER;
 633
 634   totalBytesRead.u.LowPart = totalBytesRead.u.HighPart = 0;
 635   totalBytesWritten.u.LowPart = totalBytesWritten.u.HighPart = 0;
 636
 637   /*
 638    * use stack to store data temporarily
 639    * there is surely a more performant way of doing it, for now this basic
 640    * implementation will do the job
 641    */
 642   while ( cb.u.LowPart > 0 )
 643   {
 644     if ( cb.u.LowPart >= 128 )
 645       copySize = 128;
 646     else
 647       copySize = cb.u.LowPart;
 648
 649     IStream_Read(iface, tmpBuffer, copySize, &bytesRead);
 650
 651     totalBytesRead.u.LowPart += bytesRead;
 652
 653     IStream_Write(pstm, tmpBuffer, bytesRead, &bytesWritten);
 654
 655     totalBytesWritten.u.LowPart += bytesWritten;
 656
 657     /*
 658      * Check that read & write operations were successful
 659      */
 660     if (bytesRead != bytesWritten)
 661     {
 662       hr = STG_E_MEDIUMFULL;
 663       break;
 664     }
 665
 666     if (bytesRead!=copySize)
 667       cb.u.LowPart = 0;
 668     else
 669       cb.u.LowPart -= bytesRead;
 670   }
 671
 672   /*
 673    * Update number of bytes read and written
 674    */
 675   if (pcbRead)
 676   {
 677     pcbRead->u.LowPart = totalBytesRead.u.LowPart;
 678     pcbRead->u.HighPart = totalBytesRead.u.HighPart;
 679   }
 680
 681   if (pcbWritten)
 682   {
 683     pcbWritten->u.LowPart = totalBytesWritten.u.LowPart;
 684     pcbWritten->u.HighPart = totalBytesWritten.u.HighPart;
 685   }
 686   return hr;
 687 }
 688
 689 /***
 690  * This method is part of the IStream interface.
 691  *
 692  * For streams contained in structured storages, this method
 693  * does nothing. This is what the documentation tells us.
 694  *
 695  * See the documentation of IStream for more info.
 696  */
 697 static HRESULT WINAPI StgStreamImpl_Commit(
 698                   IStream*      iface,
 699                   DWORD           grfCommitFlags)  /* [in] */
 700 {
 701   return S_OK;
 702 }
 703
 704 /***
 705  * This method is part of the IStream interface.
 706  *
 707  * For streams contained in structured storages, this method
 708  * does nothing. This is what the documentation tells us.
 709  *
 710  * See the documentation of IStream for more info.
 711  */
 712 static HRESULT WINAPI StgStreamImpl_Revert(
 713                   IStream* iface)
 714 {
 715   return S_OK;
 716 }
 717
 718 static HRESULT WINAPI StgStreamImpl_LockRegion(
 719                                         IStream*     iface,
 720                                         ULARGE_INTEGER libOffset,   /* [in] */
 721                                         ULARGE_INTEGER cb,          /* [in] */
 722                                         DWORD          dwLockType)  /* [in] */
 723 {
 724   FIXME("not implemented!\n");
 725   return E_NOTIMPL;
 726 }
 727
 728 static HRESULT WINAPI StgStreamImpl_UnlockRegion(
 729                                           IStream*     iface,
 730                                           ULARGE_INTEGER libOffset,   /* [in] */
 731                                           ULARGE_INTEGER cb,          /* [in] */
 732                                           DWORD          dwLockType)  /* [in] */
 733 {
 734   FIXME("not implemented!\n");
 735   return E_NOTIMPL;
 736 }
 737
 738 /***
 739  * This method is part of the IStream interface.
 740  *
 741  * This method returns information about the current
 742  * stream.
 743  *
 744  * See the documentation of IStream for more info.
 745  */
 746 static HRESULT WINAPI StgStreamImpl_Stat(
 747                   IStream*     iface,
 748                   STATSTG*       pstatstg,     /* [out] */
 749                   DWORD          grfStatFlag)  /* [in] */
 750 {
 751   StgStreamImpl* const This=(StgStreamImpl*)iface;
 752
 753   StgProperty    curProperty;
 754   BOOL         readSucessful;
 755
 756   /*
 757    * Read the information from the property.
 758    */
 759   readSucessful = StorageImpl_ReadProperty(This->parentStorage->ancestorStorage,
 760                                              This->ownerProperty,
 761                                              &curProperty);
 762
 763   if (readSucessful)
 764   {
 765     StorageUtl_CopyPropertyToSTATSTG(pstatstg,
 766                                      &curProperty,
 767                                      grfStatFlag);
 768
 769     pstatstg->grfMode = This->grfMode;
 770
 771     return S_OK;
 772   }
 773
 774   return E_FAIL;
 775 }
 776
 777 /***
 778  * This method is part of the IStream interface.
 779  *
 780  * This method returns a clone of the interface that allows for
 781  * another seek pointer
 782  *
 783  * See the documentation of IStream for more info.
 784  *
 785  * I am not totally sure what I am doing here but I presume that this
 786  * should be basically as simple as creating a new stream with the same
 787  * parent etc and positioning its seek cursor.
 788  */
 789 static HRESULT WINAPI StgStreamImpl_Clone(
 790                                    IStream*     iface,
 791                                    IStream**    ppstm) /* [out] */
 792 {
 793   StgStreamImpl* const This=(StgStreamImpl*)iface;
 794   HRESULT hres;
 795   StgStreamImpl* new_stream;
 796   LARGE_INTEGER seek_pos;
 797
 798   /*
 799    * Sanity check
 800    */
 801   if ( ppstm == 0 )
 802     return STG_E_INVALIDPOINTER;
 803
 804   new_stream = StgStreamImpl_Construct (This->parentStorage, This->grfMode, This->ownerProperty);
 805
 806   if (!new_stream)
 807     return STG_E_INSUFFICIENTMEMORY; /* Currently the only reason for new_stream=0 */
 808
 809   *ppstm = (IStream*) new_stream;
 810   seek_pos.QuadPart = This->currentPosition.QuadPart;
 811
 812   hres=StgStreamImpl_Seek (*ppstm, seek_pos, STREAM_SEEK_SET, NULL);
 813
 814   assert (SUCCEEDED(hres));
 815
 816   return S_OK;
 817 }
 818
 819 /*
 820  * Virtual function table for the StgStreamImpl class.
 821  */
 822 static const IStreamVtbl StgStreamImpl_Vtbl =
 823 {
 824     StgStreamImpl_QueryInterface,
 825     StgStreamImpl_AddRef,
 826     StgStreamImpl_Release,
 827     StgStreamImpl_Read,
 828     StgStreamImpl_Write,
 829     StgStreamImpl_Seek,
 830     StgStreamImpl_SetSize,
 831     StgStreamImpl_CopyTo,
 832     StgStreamImpl_Commit,
 833     StgStreamImpl_Revert,
 834     StgStreamImpl_LockRegion,
 835     StgStreamImpl_UnlockRegion,
 836     StgStreamImpl_Stat,
 837     StgStreamImpl_Clone
 838 };
 839
 840 /******************************************************************************
 841 ** StgStreamImpl implementation
 842 */
 843
 844 /***
 845  * This is the constructor for the StgStreamImpl class.
 846  *
 847  * Params:
 848  *    parentStorage - Pointer to the storage that contains the stream to open
 849  *    ownerProperty - Index of the property that points to this stream.
 850  */
 851 StgStreamImpl* StgStreamImpl_Construct(
 852                 StorageBaseImpl* parentStorage,
 853     DWORD            grfMode,
 854     ULONG            ownerProperty)
 855 {
 856   StgStreamImpl* newStream;
 857
 858   newStream = HeapAlloc(GetProcessHeap(), 0, sizeof(StgStreamImpl));
 859
 860   if (newStream!=0)
 861   {
 862     /*
 863      * Set-up the virtual function table and reference count.
 864      */
 865     newStream->lpVtbl    = &StgStreamImpl_Vtbl;
 866     newStream->ref       = 0;
 867
 868     /*
 869      * We want to nail-down the reference to the storage in case the
 870      * stream out-lives the storage in the client application.
 871      */
 872     newStream->parentStorage = parentStorage;
 873     IStorage_AddRef((IStorage*)newStream->parentStorage);
 874
 875     newStream->grfMode = grfMode;
 876     newStream->ownerProperty = ownerProperty;
 877
 878     /*
 879      * Start the stream at the beginning.
 880      */
 881     newStream->currentPosition.u.HighPart = 0;
 882     newStream->currentPosition.u.LowPart = 0;
 883
 884     /*
 885      * Initialize the rest of the data.
 886      */
 887     newStream->streamSize.u.HighPart = 0;
 888     newStream->streamSize.u.LowPart  = 0;
 889     newStream->bigBlockChain       = 0;
 890     newStream->smallBlockChain     = 0;
 891
 892     /*
 893      * Read the size from the property and determine if the blocks forming
 894      * this stream are large or small.
 895      */
 896     StgStreamImpl_OpenBlockChain(newStream);
 897   }
 898
 899   return newStream;
 900 }